global reindent, now with uncrustify hook enabled

1 files changed, 336 insertions, 333 deletions

diff --git a/src/util/mq.c b/src/util/mq.c
index 188606fb4..1c1f2893f 100644
--- a/src/util/mq.c
+++ b/src/util/mq.c
@@ -26,10 +26,11 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "util-mq", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "util-mq", __VA_ARGS__)
 
 
-struct GNUNET_MQ_Envelope {
+struct GNUNET_MQ_Envelope
+{
   /**
    * Messages are stored in a linked list.
    * Each queue has its own list of envelopes.
@@ -81,7 +82,8 @@ struct GNUNET_MQ_Envelope {
 /**
  * Handle to a message queue.
  */
-struct GNUNET_MQ_Handle {
+struct GNUNET_MQ_Handle
+{
   /**
    * Handlers array, or NULL if the queue should not receive messages
    */
@@ -197,17 +199,17 @@ struct GNUNET_MQ_Handle {
  * @param mh message to dispatch
  */
 void
-GNUNET_MQ_inject_message(struct GNUNET_MQ_Handle *mq,
-                         const struct GNUNET_MessageHeader *mh)
+GNUNET_MQ_inject_message (struct GNUNET_MQ_Handle *mq,
+                          const struct GNUNET_MessageHeader *mh)
 {
   int ret;
 
-  ret = GNUNET_MQ_handle_message(mq->handlers, mh);
+  ret = GNUNET_MQ_handle_message (mq->handlers, mh);
   if (GNUNET_SYSERR == ret)
-    {
-      GNUNET_MQ_inject_error(mq, GNUNET_MQ_ERROR_MALFORMED);
-      return;
-    }
+  {
+    GNUNET_MQ_inject_error (mq, GNUNET_MQ_ERROR_MALFORMED);
+    return;
+  }
 }
 
 
@@ -224,62 +226,62 @@ GNUNET_MQ_inject_message(struct GNUNET_MQ_Handle *mq,
  *         #GNUNET_SYSERR if message was rejected by check function
  */
 int
-GNUNET_MQ_handle_message(const struct GNUNET_MQ_MessageHandler *handlers,
-                         const struct GNUNET_MessageHeader *mh)
+GNUNET_MQ_handle_message (const struct GNUNET_MQ_MessageHandler *handlers,
+                          const struct GNUNET_MessageHeader *mh)
 {
   const struct GNUNET_MQ_MessageHandler *handler;
   int handled = GNUNET_NO;
-  uint16_t msize = ntohs(mh->size);
-  uint16_t mtype = ntohs(mh->type);
+  uint16_t msize = ntohs (mh->size);
+  uint16_t mtype = ntohs (mh->type);
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Received message of type %u and size %u\n",
-      mtype,
-      msize);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received message of type %u and size %u\n",
+       mtype,
+       msize);
 
   if (NULL == handlers)
     goto done;
   for (handler = handlers; NULL != handler->cb; handler++)
+  {
+    if (handler->type == mtype)
     {
-      if (handler->type == mtype)
-        {
-          handled = GNUNET_YES;
-          if ((handler->expected_size > msize) ||
-              ((handler->expected_size != msize) && (NULL == handler->mv)))
-            {
-              /* Too small, or not an exact size and
-                 no 'mv' handler to check rest */
-              LOG(GNUNET_ERROR_TYPE_ERROR,
-                  "Received malformed message of type %u\n",
-                  (unsigned int)handler->type);
-              return GNUNET_SYSERR;
-            }
-          if ((NULL == handler->mv) ||
-              (GNUNET_OK == handler->mv(handler->cls, mh)))
-            {
-              /* message well-formed, pass to handler */
-              handler->cb(handler->cls, mh);
-            }
-          else
-            {
-              /* Message rejected by check routine */
-              LOG(GNUNET_ERROR_TYPE_ERROR,
-                  "Received malformed message of type %u\n",
-                  (unsigned int)handler->type);
-              return GNUNET_SYSERR;
-            }
-          break;
-        }
+      handled = GNUNET_YES;
+      if ((handler->expected_size > msize) ||
+          ((handler->expected_size != msize) && (NULL == handler->mv)))
+      {
+        /* Too small, or not an exact size and
+           no 'mv' handler to check rest */
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             "Received malformed message of type %u\n",
+             (unsigned int) handler->type);
+        return GNUNET_SYSERR;
+      }
+      if ((NULL == handler->mv) ||
+          (GNUNET_OK == handler->mv (handler->cls, mh)))
+      {
+        /* message well-formed, pass to handler */
+        handler->cb (handler->cls, mh);
+      }
+      else
+      {
+        /* Message rejected by check routine */
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             "Received malformed message of type %u\n",
+             (unsigned int) handler->type);
+        return GNUNET_SYSERR;
+      }
+      break;
     }
+  }
 done:
   if (GNUNET_NO == handled)
-    {
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "No handler for message of type %u and size %u\n",
-          mtype,
-          msize);
-      return GNUNET_NO;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "No handler for message of type %u and size %u\n",
+         mtype,
+         msize);
+    return GNUNET_NO;
+  }
   return GNUNET_OK;
 }
 
@@ -295,16 +297,16 @@ done:
  * @param error the error type
  */
 void
-GNUNET_MQ_inject_error(struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error)
+GNUNET_MQ_inject_error (struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error)
 {
   if (NULL == mq->error_handler)
-    {
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          "Got error %d, but no handler installed\n",
-          (int)error);
-      return;
-    }
-  mq->error_handler(mq->error_handler_cls, error);
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Got error %d, but no handler installed\n",
+         (int) error);
+    return;
+  }
+  mq->error_handler (mq->error_handler_cls, error);
 }
 
 
@@ -316,10 +318,10 @@ GNUNET_MQ_inject_error(struct GNUNET_MQ_Handle *mq, enum GNUNET_MQ_Error error)
  * @param mqm the message to discard
  */
 void
-GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_discard (struct GNUNET_MQ_Envelope *ev)
 {
-  GNUNET_assert(NULL == ev->parent_queue);
-  GNUNET_free(ev);
+  GNUNET_assert (NULL == ev->parent_queue);
+  GNUNET_free (ev);
 }
 
 
@@ -330,12 +332,12 @@ GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *ev)
  * @return number of queued, non-transmitted messages
  */
 unsigned int
-GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_get_length (struct GNUNET_MQ_Handle *mq)
 {
   if (GNUNET_YES != mq->in_flight)
-    {
-      return mq->queue_length;
-    }
+  {
+    return mq->queue_length;
+  }
   return mq->queue_length - 1;
 }
 
@@ -348,36 +350,36 @@ GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
  * @param ev the envelope with the message to send.
  */
 void
-GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_send (struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
 {
-  GNUNET_assert(NULL != mq);
-  GNUNET_assert(NULL == ev->parent_queue);
+  GNUNET_assert (NULL != mq);
+  GNUNET_assert (NULL == ev->parent_queue);
 
   mq->queue_length++;
   if (mq->queue_length >= 10000)
-    {
-      /* This would seem like a bug... */
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "MQ with %u entries extended by message of type %u (FC broken?)\n",
-                 (unsigned int)mq->queue_length,
-                 (unsigned int)ntohs(ev->mh->type));
-    }
+  {
+    /* This would seem like a bug... */
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "MQ with %u entries extended by message of type %u (FC broken?)\n",
+                (unsigned int) mq->queue_length,
+                (unsigned int) ntohs (ev->mh->type));
+  }
   ev->parent_queue = mq;
   /* is the implementation busy? queue it! */
   if ((NULL != mq->current_envelope) || (NULL != mq->send_task))
-    {
-      GNUNET_CONTAINER_DLL_insert_tail(mq->envelope_head, mq->envelope_tail, ev);
-      return;
-    }
-  GNUNET_assert(NULL == mq->envelope_head);
+  {
+    GNUNET_CONTAINER_DLL_insert_tail (mq->envelope_head, mq->envelope_tail, ev);
+    return;
+  }
+  GNUNET_assert (NULL == mq->envelope_head);
   mq->current_envelope = ev;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "sending message of type %u, queue empty (MQ: %p)\n",
-      ntohs(ev->mh->type),
-      mq);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "sending message of type %u, queue empty (MQ: %p)\n",
+       ntohs (ev->mh->type),
+       mq);
 
-  mq->send_impl(mq, ev->mh, mq->impl_state);
+  mq->send_impl (mq, ev->mh, mq->impl_state);
 }
 
 
@@ -389,12 +391,12 @@ GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
  * @return NULL if queue is empty (or has no envelope that is not under transmission)
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_unsent_head(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_unsent_head (struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_Envelope *env;
 
   env = mq->envelope_head;
-  GNUNET_CONTAINER_DLL_remove(mq->envelope_head, mq->envelope_tail, env);
+  GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, env);
   mq->queue_length--;
   env->parent_queue = NULL;
   return env;
@@ -409,13 +411,13 @@ GNUNET_MQ_unsent_head(struct GNUNET_MQ_Handle *mq)
  * @return copy of @a env
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_env_copy(struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_env_copy (struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_assert(NULL == env->next);
-  GNUNET_assert(NULL == env->parent_queue);
-  GNUNET_assert(NULL == env->sent_cb);
-  GNUNET_assert(GNUNET_NO == env->have_custom_options);
-  return GNUNET_MQ_msg_copy(env->mh);
+  GNUNET_assert (NULL == env->next);
+  GNUNET_assert (NULL == env->parent_queue);
+  GNUNET_assert (NULL == env->sent_cb);
+  GNUNET_assert (GNUNET_NO == env->have_custom_options);
+  return GNUNET_MQ_msg_copy (env->mh);
 }
 
 
@@ -427,19 +429,19 @@ GNUNET_MQ_env_copy(struct GNUNET_MQ_Envelope *env)
  * @param ev the envelope with the message to send.
  */
 void
-GNUNET_MQ_send_copy(struct GNUNET_MQ_Handle *mq,
-                    const struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_send_copy (struct GNUNET_MQ_Handle *mq,
+                     const struct GNUNET_MQ_Envelope *ev)
 {
   struct GNUNET_MQ_Envelope *env;
   uint16_t msize;
 
-  msize = ntohs(ev->mh->size);
-  env = GNUNET_malloc(sizeof(struct GNUNET_MQ_Envelope) + msize);
-  env->mh = (struct GNUNET_MessageHeader *)&env[1];
+  msize = ntohs (ev->mh->size);
+  env = GNUNET_malloc (sizeof(struct GNUNET_MQ_Envelope) + msize);
+  env->mh = (struct GNUNET_MessageHeader *) &env[1];
   env->sent_cb = ev->sent_cb;
   env->sent_cls = ev->sent_cls;
-  GNUNET_memcpy(&env[1], ev->mh, msize);
-  GNUNET_MQ_send(mq, env);
+  GNUNET_memcpy (&env[1], ev->mh, msize);
+  GNUNET_MQ_send (mq, env);
 }
 
 
@@ -451,7 +453,7 @@ GNUNET_MQ_send_copy(struct GNUNET_MQ_Handle *mq,
  * @param cls message queue to send the next message with
  */
 static void
-impl_send_continue(void *cls)
+impl_send_continue (void *cls)
 {
   struct GNUNET_MQ_Handle *mq = cls;
 
@@ -461,15 +463,15 @@ impl_send_continue(void *cls)
   if (NULL == mq->envelope_head)
     return;
   mq->current_envelope = mq->envelope_head;
-  GNUNET_CONTAINER_DLL_remove(mq->envelope_head,
-                              mq->envelope_tail,
-                              mq->current_envelope);
+  GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
+                               mq->envelope_tail,
+                               mq->current_envelope);
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "sending message of type %u from queue\n",
-      ntohs(mq->current_envelope->mh->type));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "sending message of type %u from queue\n",
+       ntohs (mq->current_envelope->mh->type));
 
-  mq->send_impl(mq, mq->current_envelope->mh, mq->impl_state);
+  mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
 }
 
 
@@ -481,25 +483,25 @@ impl_send_continue(void *cls)
  * @param mq message queue to send the next message with
  */
 void
-GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_impl_send_continue (struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_Envelope *current_envelope;
   GNUNET_SCHEDULER_TaskCallback cb;
 
-  GNUNET_assert(0 < mq->queue_length);
+  GNUNET_assert (0 < mq->queue_length);
   mq->queue_length--;
   mq->in_flight = GNUNET_NO;
   current_envelope = mq->current_envelope;
   current_envelope->parent_queue = NULL;
   mq->current_envelope = NULL;
-  GNUNET_assert(NULL == mq->send_task);
-  mq->send_task = GNUNET_SCHEDULER_add_now(&impl_send_continue, mq);
+  GNUNET_assert (NULL == mq->send_task);
+  mq->send_task = GNUNET_SCHEDULER_add_now (&impl_send_continue, mq);
   if (NULL != (cb = current_envelope->sent_cb))
-    {
-      current_envelope->sent_cb = NULL;
-      cb(current_envelope->sent_cls);
-    }
-  GNUNET_free(current_envelope);
+  {
+    current_envelope->sent_cb = NULL;
+    cb (current_envelope->sent_cls);
+  }
+  GNUNET_free (current_envelope);
 }
 
 
@@ -514,7 +516,7 @@ GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
  * @param mq message queue to send the next message with
  */
 void
-GNUNET_MQ_impl_send_in_flight(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_impl_send_in_flight (struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_Envelope *current_envelope;
   GNUNET_SCHEDULER_TaskCallback cb;
@@ -523,14 +525,14 @@ GNUNET_MQ_impl_send_in_flight(struct GNUNET_MQ_Handle *mq)
   /* call is only valid if we're actually currently sending
    * a message */
   current_envelope = mq->current_envelope;
-  GNUNET_assert(NULL != current_envelope);
+  GNUNET_assert (NULL != current_envelope);
   /* can't call cancel from now on anymore */
   current_envelope->parent_queue = NULL;
   if (NULL != (cb = current_envelope->sent_cb))
-    {
-      current_envelope->sent_cb = NULL;
-      cb(current_envelope->sent_cls);
-    }
+  {
+    current_envelope->sent_cb = NULL;
+    cb (current_envelope->sent_cls);
+  }
 }
 
 
@@ -547,21 +549,21 @@ GNUNET_MQ_impl_send_in_flight(struct GNUNET_MQ_Handle *mq)
  * @return a new message queue
  */
 struct GNUNET_MQ_Handle *
-GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send,
-                              GNUNET_MQ_DestroyImpl destroy,
-                              GNUNET_MQ_CancelImpl cancel,
-                              void *impl_state,
-                              const struct GNUNET_MQ_MessageHandler *handlers,
-                              GNUNET_MQ_ErrorHandler error_handler,
-                              void *error_handler_cls)
+GNUNET_MQ_queue_for_callbacks (GNUNET_MQ_SendImpl send,
+                               GNUNET_MQ_DestroyImpl destroy,
+                               GNUNET_MQ_CancelImpl cancel,
+                               void *impl_state,
+                               const struct GNUNET_MQ_MessageHandler *handlers,
+                               GNUNET_MQ_ErrorHandler error_handler,
+                               void *error_handler_cls)
 {
   struct GNUNET_MQ_Handle *mq;
 
-  mq = GNUNET_new(struct GNUNET_MQ_Handle);
+  mq = GNUNET_new (struct GNUNET_MQ_Handle);
   mq->send_impl = send;
   mq->destroy_impl = destroy;
   mq->cancel_impl = cancel;
-  mq->handlers = GNUNET_MQ_copy_handlers(handlers);
+  mq->handlers = GNUNET_MQ_copy_handlers (handlers);
   mq->error_handler = error_handler;
   mq->error_handler_cls = error_handler_cls;
   mq->impl_state = impl_state;
@@ -578,7 +580,7 @@ GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send,
  * @param handlers_cls new closure to use
  */
 void
-GNUNET_MQ_set_handlers_closure(struct GNUNET_MQ_Handle *mq, void *handlers_cls)
+GNUNET_MQ_set_handlers_closure (struct GNUNET_MQ_Handle *mq, void *handlers_cls)
 {
   if (NULL == mq->handlers)
     return;
@@ -597,10 +599,10 @@ GNUNET_MQ_set_handlers_closure(struct GNUNET_MQ_Handle *mq, void *handlers_cls)
  * @return message to send, never NULL
  */
 const struct GNUNET_MessageHeader *
-GNUNET_MQ_impl_current(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_impl_current (struct GNUNET_MQ_Handle *mq)
 {
-  GNUNET_assert(NULL != mq->current_envelope);
-  GNUNET_assert(NULL != mq->current_envelope->mh);
+  GNUNET_assert (NULL != mq->current_envelope);
+  GNUNET_assert (NULL != mq->current_envelope->mh);
   return mq->current_envelope->mh;
 }
 
@@ -620,21 +622,21 @@ GNUNET_MQ_impl_current(struct GNUNET_MQ_Handle *mq)
  * @return message to send, never NULL
  */
 void *
-GNUNET_MQ_impl_state(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_impl_state (struct GNUNET_MQ_Handle *mq)
 {
   return mq->impl_state;
 }
 
 
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_msg_(struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t type)
+GNUNET_MQ_msg_ (struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t type)
 {
   struct GNUNET_MQ_Envelope *ev;
 
-  ev = GNUNET_malloc(size + sizeof(struct GNUNET_MQ_Envelope));
-  ev->mh = (struct GNUNET_MessageHeader *)&ev[1];
-  ev->mh->size = htons(size);
-  ev->mh->type = htons(type);
+  ev = GNUNET_malloc (size + sizeof(struct GNUNET_MQ_Envelope));
+  ev->mh = (struct GNUNET_MessageHeader *) &ev[1];
+  ev->mh->size = htons (size);
+  ev->mh->type = htons (type);
   if (NULL != mhp)
     *mhp = ev->mh;
   return ev;
@@ -648,14 +650,14 @@ GNUNET_MQ_msg_(struct GNUNET_MessageHeader **mhp, uint16_t size, uint16_t type)
  * @return envelope containing @a hdr
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
+GNUNET_MQ_msg_copy (const struct GNUNET_MessageHeader *hdr)
 {
   struct GNUNET_MQ_Envelope *mqm;
-  uint16_t size = ntohs(hdr->size);
+  uint16_t size = ntohs (hdr->size);
 
-  mqm = GNUNET_malloc(sizeof(*mqm) + size);
-  mqm->mh = (struct GNUNET_MessageHeader *)&mqm[1];
-  GNUNET_memcpy(mqm->mh, hdr, size);
+  mqm = GNUNET_malloc (sizeof(*mqm) + size);
+  mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1];
+  GNUNET_memcpy (mqm->mh, hdr, size);
   return mqm;
 }
 
@@ -670,27 +672,27 @@ GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
  * @param nested_mh the message to append to the message after base_size
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_msg_nested_mh_(struct GNUNET_MessageHeader **mhp,
-                         uint16_t base_size,
-                         uint16_t type,
-                         const struct GNUNET_MessageHeader *nested_mh)
+GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader **mhp,
+                          uint16_t base_size,
+                          uint16_t type,
+                          const struct GNUNET_MessageHeader *nested_mh)
 {
   struct GNUNET_MQ_Envelope *mqm;
   uint16_t size;
 
   if (NULL == nested_mh)
-    return GNUNET_MQ_msg_(mhp, base_size, type);
+    return GNUNET_MQ_msg_ (mhp, base_size, type);
 
-  size = base_size + ntohs(nested_mh->size);
+  size = base_size + ntohs (nested_mh->size);
 
   /* check for uint16_t overflow */
   if (size < base_size)
     return NULL;
 
-  mqm = GNUNET_MQ_msg_(mhp, size, type);
-  GNUNET_memcpy((char *)mqm->mh + base_size,
-                nested_mh,
-                ntohs(nested_mh->size));
+  mqm = GNUNET_MQ_msg_ (mhp, size, type);
+  GNUNET_memcpy ((char *) mqm->mh + base_size,
+                 nested_mh,
+                 ntohs (nested_mh->size));
 
   return mqm;
 }
@@ -703,22 +705,22 @@ GNUNET_MQ_msg_nested_mh_(struct GNUNET_MessageHeader **mhp,
  * @param assoc_data to associate
  */
 uint32_t
-GNUNET_MQ_assoc_add(struct GNUNET_MQ_Handle *mq, void *assoc_data)
+GNUNET_MQ_assoc_add (struct GNUNET_MQ_Handle *mq, void *assoc_data)
 {
   uint32_t id;
 
   if (NULL == mq->assoc_map)
-    {
-      mq->assoc_map = GNUNET_CONTAINER_multihashmap32_create(8);
-      mq->assoc_id = 1;
-    }
+  {
+    mq->assoc_map = GNUNET_CONTAINER_multihashmap32_create (8);
+    mq->assoc_id = 1;
+  }
   id = mq->assoc_id++;
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap32_put(
-                  mq->assoc_map,
-                  id,
-                  assoc_data,
-                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap32_put (
+                   mq->assoc_map,
+                   id,
+                   assoc_data,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return id;
 }
 
@@ -731,11 +733,11 @@ GNUNET_MQ_assoc_add(struct GNUNET_MQ_Handle *mq, void *assoc_data)
  * @return the associated data
  */
 void *
-GNUNET_MQ_assoc_get(struct GNUNET_MQ_Handle *mq, uint32_t request_id)
+GNUNET_MQ_assoc_get (struct GNUNET_MQ_Handle *mq, uint32_t request_id)
 {
   if (NULL == mq->assoc_map)
     return NULL;
-  return GNUNET_CONTAINER_multihashmap32_get(mq->assoc_map, request_id);
+  return GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id);
 }
 
 
@@ -747,14 +749,14 @@ GNUNET_MQ_assoc_get(struct GNUNET_MQ_Handle *mq, uint32_t request_id)
  * @return the associated data
  */
 void *
-GNUNET_MQ_assoc_remove(struct GNUNET_MQ_Handle *mq, uint32_t request_id)
+GNUNET_MQ_assoc_remove (struct GNUNET_MQ_Handle *mq, uint32_t request_id)
 {
   void *val;
 
   if (NULL == mq->assoc_map)
     return NULL;
-  val = GNUNET_CONTAINER_multihashmap32_get(mq->assoc_map, request_id);
-  GNUNET_CONTAINER_multihashmap32_remove_all(mq->assoc_map, request_id);
+  val = GNUNET_CONTAINER_multihashmap32_get (mq->assoc_map, request_id);
+  GNUNET_CONTAINER_multihashmap32_remove_all (mq->assoc_map, request_id);
   return val;
 }
 
@@ -769,12 +771,12 @@ GNUNET_MQ_assoc_remove(struct GNUNET_MQ_Handle *mq, uint32_t request_id)
  * @param cb_cls closure for the callback
  */
 void
-GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev,
-                      GNUNET_SCHEDULER_TaskCallback cb,
-                      void *cb_cls)
+GNUNET_MQ_notify_sent (struct GNUNET_MQ_Envelope *ev,
+                       GNUNET_SCHEDULER_TaskCallback cb,
+                       void *cb_cls)
 {
   /* allow setting *OR* clearing callback */
-  GNUNET_assert((NULL == ev->sent_cb) || (NULL == cb));
+  GNUNET_assert ((NULL == ev->sent_cb) || (NULL == cb));
   ev->sent_cb = cb;
   ev->sent_cls = cb_cls;
 }
@@ -784,7 +786,8 @@ GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev,
  * Handle we return for callbacks registered to be
  * notified when #GNUNET_MQ_destroy() is called on a queue.
  */
-struct GNUNET_MQ_DestroyNotificationHandle {
+struct GNUNET_MQ_DestroyNotificationHandle
+{
   /**
    * Kept in a DLL.
    */
@@ -818,86 +821,86 @@ struct GNUNET_MQ_DestroyNotificationHandle {
  * @param mq message queue to destroy
  */
 void
-GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_destroy (struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_DestroyNotificationHandle *dnh;
 
   if (NULL != mq->destroy_impl)
-    {
-      mq->destroy_impl(mq, mq->impl_state);
-    }
+  {
+    mq->destroy_impl (mq, mq->impl_state);
+  }
   if (NULL != mq->send_task)
-    {
-      GNUNET_SCHEDULER_cancel(mq->send_task);
-      mq->send_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (mq->send_task);
+    mq->send_task = NULL;
+  }
   while (NULL != mq->envelope_head)
-    {
-      struct GNUNET_MQ_Envelope *ev;
-
-      ev = mq->envelope_head;
-      ev->parent_queue = NULL;
-      GNUNET_CONTAINER_DLL_remove(mq->envelope_head, mq->envelope_tail, ev);
-      GNUNET_assert(0 < mq->queue_length);
-      mq->queue_length--;
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "MQ destroy drops message of type %u\n",
-          ntohs(ev->mh->type));
-      GNUNET_MQ_discard(ev);
-    }
+  {
+    struct GNUNET_MQ_Envelope *ev;
+
+    ev = mq->envelope_head;
+    ev->parent_queue = NULL;
+    GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev);
+    GNUNET_assert (0 < mq->queue_length);
+    mq->queue_length--;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "MQ destroy drops message of type %u\n",
+         ntohs (ev->mh->type));
+    GNUNET_MQ_discard (ev);
+  }
   if (NULL != mq->current_envelope)
-    {
-      /* we can only discard envelopes that
-       * are not queued! */
-      mq->current_envelope->parent_queue = NULL;
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "MQ destroy drops current message of type %u\n",
-          ntohs(mq->current_envelope->mh->type));
-      GNUNET_MQ_discard(mq->current_envelope);
-      mq->current_envelope = NULL;
-      GNUNET_assert(0 < mq->queue_length);
-      mq->queue_length--;
-    }
-  GNUNET_assert(0 == mq->queue_length);
+  {
+    /* we can only discard envelopes that
+     * are not queued! */
+    mq->current_envelope->parent_queue = NULL;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "MQ destroy drops current message of type %u\n",
+         ntohs (mq->current_envelope->mh->type));
+    GNUNET_MQ_discard (mq->current_envelope);
+    mq->current_envelope = NULL;
+    GNUNET_assert (0 < mq->queue_length);
+    mq->queue_length--;
+  }
+  GNUNET_assert (0 == mq->queue_length);
   while (NULL != (dnh = mq->dnh_head))
-    {
-      dnh->cb(dnh->cb_cls);
-      GNUNET_MQ_destroy_notify_cancel(dnh);
-    }
+  {
+    dnh->cb (dnh->cb_cls);
+    GNUNET_MQ_destroy_notify_cancel (dnh);
+  }
   if (NULL != mq->assoc_map)
-    {
-      GNUNET_CONTAINER_multihashmap32_destroy(mq->assoc_map);
-      mq->assoc_map = NULL;
-    }
-  GNUNET_free_non_null(mq->handlers);
-  GNUNET_free(mq);
+  {
+    GNUNET_CONTAINER_multihashmap32_destroy (mq->assoc_map);
+    mq->assoc_map = NULL;
+  }
+  GNUNET_free_non_null (mq->handlers);
+  GNUNET_free (mq);
 }
 
 
 const struct GNUNET_MessageHeader *
-GNUNET_MQ_extract_nested_mh_(const struct GNUNET_MessageHeader *mh,
-                             uint16_t base_size)
+GNUNET_MQ_extract_nested_mh_ (const struct GNUNET_MessageHeader *mh,
+                              uint16_t base_size)
 {
   uint16_t whole_size;
   uint16_t nested_size;
   const struct GNUNET_MessageHeader *nested_msg;
 
-  whole_size = ntohs(mh->size);
-  GNUNET_assert(whole_size >= base_size);
+  whole_size = ntohs (mh->size);
+  GNUNET_assert (whole_size >= base_size);
   nested_size = whole_size - base_size;
   if (0 == nested_size)
     return NULL;
   if (nested_size < sizeof(struct GNUNET_MessageHeader))
-    {
-      GNUNET_break_op(0);
-      return NULL;
-    }
-  nested_msg = (const struct GNUNET_MessageHeader *)((char *)mh + base_size);
-  if (ntohs(nested_msg->size) != nested_size)
-    {
-      GNUNET_break_op(0);
-      return NULL;
-    }
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
+  nested_msg = (const struct GNUNET_MessageHeader *) ((char *) mh + base_size);
+  if (ntohs (nested_msg->size) != nested_size)
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
   return nested_msg;
 }
 
@@ -910,53 +913,53 @@ GNUNET_MQ_extract_nested_mh_(const struct GNUNET_MessageHeader *mh,
  * @param ev queued envelope to cancel
  */
 void
-GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
+GNUNET_MQ_send_cancel (struct GNUNET_MQ_Envelope *ev)
 {
   struct GNUNET_MQ_Handle *mq = ev->parent_queue;
 
-  GNUNET_assert(NULL != mq);
-  GNUNET_assert(NULL != mq->cancel_impl);
+  GNUNET_assert (NULL != mq);
+  GNUNET_assert (NULL != mq->cancel_impl);
 
   mq->evacuate_called = GNUNET_NO;
 
   if (mq->current_envelope == ev)
+  {
+    /* complex case, we already started with transmitting
+       the message using the callbacks. */
+    GNUNET_assert (GNUNET_NO == mq->in_flight);
+    GNUNET_assert (0 < mq->queue_length);
+    mq->queue_length--;
+    mq->cancel_impl (mq, mq->impl_state);
+    /* continue sending the next message, if any */
+    mq->current_envelope = mq->envelope_head;
+    if (NULL != mq->current_envelope)
     {
-      /* complex case, we already started with transmitting
-         the message using the callbacks. */
-      GNUNET_assert(GNUNET_NO == mq->in_flight);
-      GNUNET_assert(0 < mq->queue_length);
-      mq->queue_length--;
-      mq->cancel_impl(mq, mq->impl_state);
-      /* continue sending the next message, if any */
-      mq->current_envelope = mq->envelope_head;
-      if (NULL != mq->current_envelope)
-        {
-          GNUNET_CONTAINER_DLL_remove(mq->envelope_head,
-                                      mq->envelope_tail,
-                                      mq->current_envelope);
-
-          LOG(GNUNET_ERROR_TYPE_DEBUG,
-              "sending canceled message of type %u queue\n",
-              ntohs(ev->mh->type));
-
-          mq->send_impl(mq, mq->current_envelope->mh, mq->impl_state);
-        }
+      GNUNET_CONTAINER_DLL_remove (mq->envelope_head,
+                                   mq->envelope_tail,
+                                   mq->current_envelope);
+
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "sending canceled message of type %u queue\n",
+           ntohs (ev->mh->type));
+
+      mq->send_impl (mq, mq->current_envelope->mh, mq->impl_state);
     }
+  }
   else
-    {
-      /* simple case, message is still waiting in the queue */
-      GNUNET_CONTAINER_DLL_remove(mq->envelope_head, mq->envelope_tail, ev);
-      GNUNET_assert(0 < mq->queue_length);
-      mq->queue_length--;
-    }
+  {
+    /* simple case, message is still waiting in the queue */
+    GNUNET_CONTAINER_DLL_remove (mq->envelope_head, mq->envelope_tail, ev);
+    GNUNET_assert (0 < mq->queue_length);
+    mq->queue_length--;
+  }
 
   if (GNUNET_YES != mq->evacuate_called)
-    {
-      ev->parent_queue = NULL;
-      ev->mh = NULL;
-      /* also frees ev */
-      GNUNET_free(ev);
-    }
+  {
+    ev->parent_queue = NULL;
+    ev->mh = NULL;
+    /* also frees ev */
+    GNUNET_free (ev);
+  }
 }
 
 
@@ -968,7 +971,7 @@ GNUNET_MQ_send_cancel(struct GNUNET_MQ_Envelope *ev)
  * @return the current envelope
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_get_current_envelope(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_get_current_envelope (struct GNUNET_MQ_Handle *mq)
 {
   return mq->current_envelope;
 }
@@ -981,7 +984,7 @@ GNUNET_MQ_get_current_envelope(struct GNUNET_MQ_Handle *mq)
  * @return the last envelope in the queue
  */
 struct GNUNET_MQ_Envelope *
-GNUNET_MQ_get_last_envelope(struct GNUNET_MQ_Handle *mq)
+GNUNET_MQ_get_last_envelope (struct GNUNET_MQ_Handle *mq)
 {
   if (NULL != mq->envelope_tail)
     return mq->envelope_tail;
@@ -999,8 +1002,8 @@ GNUNET_MQ_get_last_envelope(struct GNUNET_MQ_Handle *mq)
  * @param pp priorities and preferences to apply
  */
 void
-GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env,
-                          enum GNUNET_MQ_PriorityPreferences pp)
+GNUNET_MQ_env_set_options (struct GNUNET_MQ_Envelope *env,
+                           enum GNUNET_MQ_PriorityPreferences pp)
 {
   env->priority = pp;
   env->have_custom_options = GNUNET_YES;
@@ -1014,7 +1017,7 @@ GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env,
  * @return priorities and preferences to apply for @a env
  */
 enum GNUNET_MQ_PriorityPreferences
-GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_env_get_options (struct GNUNET_MQ_Envelope *env)
 {
   struct GNUNET_MQ_Handle *mq = env->parent_queue;
 
@@ -1035,12 +1038,12 @@ GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
  * @return combined priority and preferences to use
  */
 enum GNUNET_MQ_PriorityPreferences
-GNUNET_MQ_env_combine_options(enum GNUNET_MQ_PriorityPreferences p1,
-                              enum GNUNET_MQ_PriorityPreferences p2)
+GNUNET_MQ_env_combine_options (enum GNUNET_MQ_PriorityPreferences p1,
+                               enum GNUNET_MQ_PriorityPreferences p2)
 {
   enum GNUNET_MQ_PriorityPreferences ret;
 
-  ret = GNUNET_MAX(p1 & GNUNET_MQ_PRIORITY_MASK, p2 & GNUNET_MQ_PRIORITY_MASK);
+  ret = GNUNET_MAX (p1 & GNUNET_MQ_PRIORITY_MASK, p2 & GNUNET_MQ_PRIORITY_MASK);
   ret |= ((p1 & GNUNET_MQ_PREF_UNRELIABLE) & (p2 & GNUNET_MQ_PREF_UNRELIABLE));
   ret |=
     ((p1 & GNUNET_MQ_PREF_LOW_LATENCY) | (p2 & GNUNET_MQ_PREF_LOW_LATENCY));
@@ -1060,8 +1063,8 @@ GNUNET_MQ_env_combine_options(enum GNUNET_MQ_PriorityPreferences p1,
  * @param pp priorities and preferences to apply
  */
 void
-GNUNET_MQ_set_options(struct GNUNET_MQ_Handle *mq,
-                      enum GNUNET_MQ_PriorityPreferences pp)
+GNUNET_MQ_set_options (struct GNUNET_MQ_Handle *mq,
+                       enum GNUNET_MQ_PriorityPreferences pp)
 {
   mq->priority = pp;
 }
@@ -1074,7 +1077,7 @@ GNUNET_MQ_set_options(struct GNUNET_MQ_Handle *mq,
  * @return message contained in the envelope
  */
 const struct GNUNET_MessageHeader *
-GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_env_get_msg (const struct GNUNET_MQ_Envelope *env)
 {
   return env->mh;
 }
@@ -1087,7 +1090,7 @@ GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
  * @return next one, or NULL
  */
 const struct GNUNET_MQ_Envelope *
-GNUNET_MQ_env_next(const struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_env_next (const struct GNUNET_MQ_Envelope *env)
 {
   return env->next;
 }
@@ -1103,17 +1106,17 @@ GNUNET_MQ_env_next(const struct GNUNET_MQ_Envelope *env)
  * @return handle for #GNUNET_MQ_destroy_notify_cancel().
  */
 struct GNUNET_MQ_DestroyNotificationHandle *
-GNUNET_MQ_destroy_notify(struct GNUNET_MQ_Handle *mq,
-                         GNUNET_SCHEDULER_TaskCallback cb,
-                         void *cb_cls)
+GNUNET_MQ_destroy_notify (struct GNUNET_MQ_Handle *mq,
+                          GNUNET_SCHEDULER_TaskCallback cb,
+                          void *cb_cls)
 {
   struct GNUNET_MQ_DestroyNotificationHandle *dnh;
 
-  dnh = GNUNET_new(struct GNUNET_MQ_DestroyNotificationHandle);
+  dnh = GNUNET_new (struct GNUNET_MQ_DestroyNotificationHandle);
   dnh->mq = mq;
   dnh->cb = cb;
   dnh->cb_cls = cb_cls;
-  GNUNET_CONTAINER_DLL_insert(mq->dnh_head, mq->dnh_tail, dnh);
+  GNUNET_CONTAINER_DLL_insert (mq->dnh_head, mq->dnh_tail, dnh);
   return dnh;
 }
 
@@ -1124,13 +1127,13 @@ GNUNET_MQ_destroy_notify(struct GNUNET_MQ_Handle *mq,
  * @param dnh handle for registration to cancel
  */
 void
-GNUNET_MQ_destroy_notify_cancel(
+GNUNET_MQ_destroy_notify_cancel (
   struct GNUNET_MQ_DestroyNotificationHandle *dnh)
 {
   struct GNUNET_MQ_Handle *mq = dnh->mq;
 
-  GNUNET_CONTAINER_DLL_remove(mq->dnh_head, mq->dnh_tail, dnh);
-  GNUNET_free(dnh);
+  GNUNET_CONTAINER_DLL_remove (mq->dnh_head, mq->dnh_tail, dnh);
+  GNUNET_free (dnh);
 }
 
 
@@ -1147,11 +1150,11 @@ GNUNET_MQ_destroy_notify_cancel(
  * @param[in|out] env element to insert at the tail
  */
 void
-GNUNET_MQ_dll_insert_head(struct GNUNET_MQ_Envelope **env_head,
-                          struct GNUNET_MQ_Envelope **env_tail,
-                          struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_dll_insert_head (struct GNUNET_MQ_Envelope **env_head,
+                           struct GNUNET_MQ_Envelope **env_tail,
+                           struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_CONTAINER_DLL_insert(*env_head, *env_tail, env);
+  GNUNET_CONTAINER_DLL_insert (*env_head, *env_tail, env);
 }
 
 
@@ -1168,11 +1171,11 @@ GNUNET_MQ_dll_insert_head(struct GNUNET_MQ_Envelope **env_head,
  * @param[in|out] env element to insert at the tail
  */
 void
-GNUNET_MQ_dll_insert_tail(struct GNUNET_MQ_Envelope **env_head,
-                          struct GNUNET_MQ_Envelope **env_tail,
-                          struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_dll_insert_tail (struct GNUNET_MQ_Envelope **env_head,
+                           struct GNUNET_MQ_Envelope **env_tail,
+                           struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_CONTAINER_DLL_insert_tail(*env_head, *env_tail, env);
+  GNUNET_CONTAINER_DLL_insert_tail (*env_head, *env_tail, env);
 }
 
 
@@ -1189,11 +1192,11 @@ GNUNET_MQ_dll_insert_tail(struct GNUNET_MQ_Envelope **env_head,
  * @param[in|out] env element to remove from the DLL
  */
 void
-GNUNET_MQ_dll_remove(struct GNUNET_MQ_Envelope **env_head,
-                     struct GNUNET_MQ_Envelope **env_tail,
-                     struct GNUNET_MQ_Envelope *env)
+GNUNET_MQ_dll_remove (struct GNUNET_MQ_Envelope **env_head,
+                      struct GNUNET_MQ_Envelope **env_tail,
+                      struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_CONTAINER_DLL_remove(*env_head, *env_tail, env);
+  GNUNET_CONTAINER_DLL_remove (*env_head, *env_tail, env);
 }
 
 
@@ -1208,7 +1211,7 @@ GNUNET_MQ_dll_remove(struct GNUNET_MQ_Envelope **env_head,
  *         Needs to be freed with #GNUNET_free.
  */
 struct GNUNET_MQ_MessageHandler *
-GNUNET_MQ_copy_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
+GNUNET_MQ_copy_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
 {
   struct GNUNET_MQ_MessageHandler *copy;
   unsigned int count;
@@ -1216,11 +1219,11 @@ GNUNET_MQ_copy_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
   if (NULL == handlers)
     return NULL;
 
-  count = GNUNET_MQ_count_handlers(handlers);
-  copy = GNUNET_new_array(count + 1, struct GNUNET_MQ_MessageHandler);
-  GNUNET_memcpy(copy,
-                handlers,
-                count * sizeof(struct GNUNET_MQ_MessageHandler));
+  count = GNUNET_MQ_count_handlers (handlers);
+  copy = GNUNET_new_array (count + 1, struct GNUNET_MQ_MessageHandler);
+  GNUNET_memcpy (copy,
+                 handlers,
+                 count * sizeof(struct GNUNET_MQ_MessageHandler));
   return copy;
 }
 
@@ -1238,20 +1241,20 @@ GNUNET_MQ_copy_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
  *         Needs to be freed with #GNUNET_free.
  */
 struct GNUNET_MQ_MessageHandler *
-GNUNET_MQ_copy_handlers2(const struct GNUNET_MQ_MessageHandler *handlers,
-                         GNUNET_MQ_MessageCallback agpl_handler,
-                         void *agpl_cls)
+GNUNET_MQ_copy_handlers2 (const struct GNUNET_MQ_MessageHandler *handlers,
+                          GNUNET_MQ_MessageCallback agpl_handler,
+                          void *agpl_cls)
 {
   struct GNUNET_MQ_MessageHandler *copy;
   unsigned int count;
 
   if (NULL == handlers)
     return NULL;
-  count = GNUNET_MQ_count_handlers(handlers);
-  copy = GNUNET_new_array(count + 2, struct GNUNET_MQ_MessageHandler);
-  GNUNET_memcpy(copy,
-                handlers,
-                count * sizeof(struct GNUNET_MQ_MessageHandler));
+  count = GNUNET_MQ_count_handlers (handlers);
+  copy = GNUNET_new_array (count + 2, struct GNUNET_MQ_MessageHandler);
+  GNUNET_memcpy (copy,
+                 handlers,
+                 count * sizeof(struct GNUNET_MQ_MessageHandler));
   copy[count].mv = NULL;
   copy[count].cb = agpl_handler;
   copy[count].cls = agpl_cls;
@@ -1268,7 +1271,7 @@ GNUNET_MQ_copy_handlers2(const struct GNUNET_MQ_MessageHandler *handlers,
  * @return The number of handlers in the array.
  */
 unsigned int
-GNUNET_MQ_count_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
+GNUNET_MQ_count_handlers (const struct GNUNET_MQ_MessageHandler *handlers)
 {
   unsigned int i;
 
@@ -1289,22 +1292,22 @@ GNUNET_MQ_count_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
  * @return a string or NULL if invalid
  */
 const char *
-GNUNET_MQ_preference_to_string(enum GNUNET_MQ_PreferenceKind type)
+GNUNET_MQ_preference_to_string (enum GNUNET_MQ_PreferenceKind type)
 {
   switch (type)
-    {
-    case GNUNET_MQ_PREFERENCE_NONE:
-      return "NONE";
+  {
+  case GNUNET_MQ_PREFERENCE_NONE:
+    return "NONE";
 
-    case GNUNET_MQ_PREFERENCE_BANDWIDTH:
-      return "BANDWIDTH";
+  case GNUNET_MQ_PREFERENCE_BANDWIDTH:
+    return "BANDWIDTH";
 
-    case GNUNET_MQ_PREFERENCE_LATENCY:
-      return "LATENCY";
+  case GNUNET_MQ_PREFERENCE_LATENCY:
+    return "LATENCY";
 
-    case GNUNET_MQ_PREFERENCE_RELIABILITY:
-      return "RELIABILITY";
-    }
+  case GNUNET_MQ_PREFERENCE_RELIABILITY:
+    return "RELIABILITY";
+  }
   ;
   return NULL;
 }