MESSENGER: Uncrustify

Signed-off-by: TheJackiMonster <thejackimonster@gmail.com>

1 files changed, 44 insertions, 39 deletions

diff --git a/src/messenger/messenger_api_message.c b/src/messenger/messenger_api_message.c
index 7b493f760..74b65bf71 100644
--- a/src/messenger/messenger_api_message.c
+++ b/src/messenger/messenger_api_message.c
@@ -393,32 +393,32 @@ calc_padded_length (uint16_t length)
 #define min(x, y) (x < y? x : y)
 
 #define encode_step_ext(dst, offset, src, size) do { \
-          GNUNET_memcpy (dst + offset, src, size);            \
-          offset += size;                                    \
+    GNUNET_memcpy (dst + offset, src, size);            \
+    offset += size;                                    \
 } while (0)
 
 #define encode_step(dst, offset, src) do {         \
-          encode_step_ext (dst, offset, src, sizeof(*src)); \
+    encode_step_ext (dst, offset, src, sizeof(*src)); \
 } while (0)
 
 #define encode_step_key(dst, offset, src, length) do {  \
-          ssize_t result = GNUNET_IDENTITY_write_public_key_to_buffer ( \
-            src, dst + offset, length - offset                \
-            );                                                    \
-          if (result < 0)                                       \
-          GNUNET_break (0);                                   \
-          else                                                  \
-          offset += result;                                   \
+    ssize_t result = GNUNET_IDENTITY_write_public_key_to_buffer ( \
+      src, dst + offset, length - offset                \
+      );                                                    \
+    if (result < 0)                                       \
+    GNUNET_break (0);                                   \
+    else                                                  \
+    offset += result;                                   \
 } while (0)
 
 #define encode_step_signature(dst, offset, src, length) do {  \
-          ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer ( \
-            src, dst + offset, length - offset                      \
-            );                                                          \
-          if (result < 0)                                             \
-          GNUNET_break (0);                                         \
-          else                                                        \
-          offset += result;                                         \
+    ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer ( \
+      src, dst + offset, length - offset                      \
+      );                                                          \
+    if (result < 0)                                             \
+    GNUNET_break (0);                                         \
+    else                                                        \
+    offset += result;                                         \
 } while (0)
 
 static void
@@ -568,30 +568,30 @@ encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message,
 
 
 #define decode_step_ext(src, offset, dst, size) do { \
-          GNUNET_memcpy (dst, src + offset, size);            \
-          offset += size;                                    \
+    GNUNET_memcpy (dst, src + offset, size);            \
+    offset += size;                                    \
 } while (0)
 
 #define decode_step(src, offset, dst) do {         \
-          decode_step_ext (src, offset, dst, sizeof(*dst)); \
+    decode_step_ext (src, offset, dst, sizeof(*dst)); \
 } while (0)
 
 #define decode_step_malloc(src, offset, dst, size, zero) do { \
-          dst = GNUNET_malloc (size + zero);                           \
-          if (zero) dst[size] = 0;                                    \
-          decode_step_ext (src, offset, dst, size);                    \
+    dst = GNUNET_malloc (size + zero);                           \
+    if (zero) dst[size] = 0;                                    \
+    decode_step_ext (src, offset, dst, size);                    \
 } while (0)
 
 #define decode_step_key(src, offset, dst, length) do {   \
-          enum GNUNET_GenericReturnValue result;                 \
-          size_t read;                                           \
-          result = GNUNET_IDENTITY_read_public_key_from_buffer (  \
-            src + offset, length - offset, dst, &read            \
-            );                                                     \
-          if (GNUNET_SYSERR == result)                                        \
-          GNUNET_break (0);                                     \
-          else                                                   \
-          offset += read;                                    \
+    enum GNUNET_GenericReturnValue result;                 \
+    size_t read;                                           \
+    result = GNUNET_IDENTITY_read_public_key_from_buffer (  \
+      src + offset, length - offset, dst, &read            \
+      );                                                     \
+    if (GNUNET_SYSERR == result)                                        \
+    GNUNET_break (0);                                     \
+    else                                                   \
+    offset += read;                                    \
 } while (0)
 
 static uint16_t
@@ -860,13 +860,15 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message,
   const uint16_t length = get_short_message_size (&shortened, GNUNET_YES);
   const uint16_t padded_length = calc_padded_length (
     length + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
-  );
+    );
 
   message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
   message->body.privacy.data = GNUNET_malloc (padded_length);
   message->body.privacy.length = padded_length;
-  
-  const uint16_t encoded_length = padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES;
+
+  const uint16_t encoded_length = (
+    padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
+    );
 
   encode_short_message (&shortened, encoded_length, message->body.privacy.data);
 
@@ -881,7 +883,7 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message,
     unfold_short_message (&shortened, message);
     return GNUNET_NO;
   }
-  
+
   destroy_message_body (shortened.kind, &(shortened.body));
   return GNUNET_YES;
 }
@@ -897,12 +899,15 @@ decrypt_message (struct GNUNET_MESSENGER_Message *message,
 
   if (padded_length < GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Message length too short to decrypt!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Message length too short to decrypt!\n");
 
     return GNUNET_NO;
   }
 
-  const uint16_t encoded_length = padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES;
+  const uint16_t encoded_length = (
+    padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
+    );
 
   if (GNUNET_OK != GNUNET_IDENTITY_decrypt (message->body.privacy.data,
                                             padded_length,
@@ -914,7 +919,7 @@ decrypt_message (struct GNUNET_MESSENGER_Message *message,
 
     return GNUNET_NO;
   }
-  
+
   struct GNUNET_MESSENGER_ShortMessage shortened;
 
   if (GNUNET_YES != decode_short_message (&shortened,