gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[gnunet] 02/02: MESSENGER: Uncrustify


From: gnunet
Subject: [gnunet] 02/02: MESSENGER: Uncrustify
Date: Mon, 07 Aug 2023 18:13:29 +0200

This is an automated email from the git hooks/post-receive script.

thejackimonster pushed a commit to branch master
in repository gnunet.

commit 140f9ac6d6ecd14a1ed3ee839ffe270a22ec993f
Author: TheJackiMonster <thejackimonster@gmail.com>
AuthorDate: Mon Aug 7 18:12:05 2023 +0200

    MESSENGER: Uncrustify
    
    Signed-off-by: TheJackiMonster <thejackimonster@gmail.com>
---
 src/messenger/messenger_api_message.c | 83 +++++++++++++++++++----------------
 1 file 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,

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.



reply via email to

[Prev in Thread] Current Thread [Next in Thread]