fix: apply clang-format to merged code from main

src/shared/config.c

@@ -92,22 +92,38 @@ void config_delete(Config* config) {
 }
 
 bool config_send(int file_descriptor, const Config* config) {
-  if (!send_str(file_descriptor, config->version)) return false;
-  if (!send_str(file_descriptor, config->send_directory)) return false;
-  if (!send_str(file_descriptor, config->receive_root_directory)) return false;
-  if (!send_int(file_descriptor, config->save_to_disk)) return false;
-  if (!send_int(file_descriptor, config->use_multithreading)) return false;
-  if (!send_int(file_descriptor, config->use_chunk_serialization)) return false;
-  if (!send_int(file_descriptor, config->use_compression)) return false;
-  if (!send_int(file_descriptor, config->use_metadata)) return false;
-  if (!send_int(file_descriptor, config->compression_level)) return false;
-  if (!send_int(file_descriptor, (int)config->chunk_size)) return false;
-  if (!send_int(file_descriptor, config->use_sendfile)) return false;
-  if (!send_int(file_descriptor, config->use_delete)) return false;
-  if (!send_int(file_descriptor, config->use_incremental)) return false;
-  if (!send_int(file_descriptor, config->use_delta)) return false;
-  if (!send_int(file_descriptor, (int)config->delta_block_size)) return false;
-  if (!send_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long))) return false;
+  if (!send_str(file_descriptor, config->version))
+    return false;
+  if (!send_str(file_descriptor, config->send_directory))
+    return false;
+  if (!send_str(file_descriptor, config->receive_root_directory))
+    return false;
+  if (!send_int(file_descriptor, config->save_to_disk))
+    return false;
+  if (!send_int(file_descriptor, config->use_multithreading))
+    return false;
+  if (!send_int(file_descriptor, config->use_chunk_serialization))
+    return false;
+  if (!send_int(file_descriptor, config->use_compression))
+    return false;
+  if (!send_int(file_descriptor, config->use_metadata))
+    return false;
+  if (!send_int(file_descriptor, config->compression_level))
+    return false;
+  if (!send_int(file_descriptor, (int)config->chunk_size))
+    return false;
+  if (!send_int(file_descriptor, config->use_sendfile))
+    return false;
+  if (!send_int(file_descriptor, config->use_delete))
+    return false;
+  if (!send_int(file_descriptor, config->use_incremental))
+    return false;
+  if (!send_int(file_descriptor, config->use_delta))
+    return false;
+  if (!send_int(file_descriptor, (int)config->delta_block_size))
+    return false;
+  if (!send_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long)))
+    return false;
   Status status;
   if (!receive_status(file_descriptor, &status))
     return false;
@@ -179,11 +195,14 @@ Config* config_receive(int file_descriptor) {
   if (!receive_int(file_descriptor, &tmp))
     goto error;
   config->use_incremental = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->use_delta = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->delta_block_size = (uint32_t)tmp;
-  if (!receive_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long))) goto error;
+  if (!receive_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long)))
+    goto error;
   config->show_progress = false;
   config->dry_run = false;
   config->ssh_port = 22;

src/shared/delta.c

@@ -7,8 +7,8 @@
 #define XXH_IMPLEMENTATION
 #include <xxhash.h>
 
-uint32_t delta_adler32(const void *data, uint32_t len) {
-  const uint8_t *p = (const uint8_t *)data;
+uint32_t delta_adler32(const void* data, uint32_t len) {
+  const uint8_t* p = (const uint8_t*)data;
   uint32_t s1 = 1;
   uint32_t s2 = 0;
   for (uint32_t i = 0; i < len; i++) {
@@ -18,20 +18,20 @@ uint32_t delta_adler32(const void *data, uint32_t len) {
   return (s2 << 16) | s1;
 }
 
-uint32_t delta_xxhash32(const void *data, uint32_t len) {
+uint32_t delta_xxhash32(const void* data, uint32_t len) {
   return XXH32(data, len, 0);
 }
 
-DeltaSignature *delta_signature_create(const void *old_file_data,
-                                        uint64_t old_file_size,
-                                        uint32_t block_size) {
+DeltaSignature* delta_signature_create(const void* old_file_data, uint64_t old_file_size,
+                                       uint32_t block_size) {
   if (old_file_data == NULL || old_file_size == 0 || block_size == 0)
     return NULL;
 
   uint32_t block_count = (uint32_t)((old_file_size + block_size - 1) / block_size);
 
-  DeltaSignature *sig = malloc(sizeof(DeltaSignature));
-  if (!sig) return NULL;
+  DeltaSignature* sig = malloc(sizeof(DeltaSignature));
+  if (!sig)
+    return NULL;
 
   sig->file_size = old_file_size;
   sig->block_size = block_size;
@@ -42,12 +42,11 @@ DeltaSignature *delta_signature_create(const void *old_file_data,
     return NULL;
   }
 
-  const uint8_t *data = (const uint8_t *)old_file_data;
+  const uint8_t* data = (const uint8_t*)old_file_data;
   for (uint32_t i = 0; i < block_count; i++) {
     uint64_t offset = (uint64_t)i * block_size;
-    uint32_t len = (uint32_t)((old_file_size - offset < block_size)
-                                  ? (old_file_size - offset)
-                                  : block_size);
+    uint32_t len =
+        (uint32_t)((old_file_size - offset < block_size) ? (old_file_size - offset) : block_size);
     sig->blocks[i].adler32 = delta_adler32(data + offset, len);
     sig->blocks[i].xxhash = delta_xxhash32(data + offset, len);
   }
@@ -55,14 +54,16 @@ DeltaSignature *delta_signature_create(const void *old_file_data,
   return sig;
 }
 
-Data *delta_signature_serialize(const DeltaSignature *sig) {
-  if (!sig) return NULL;
+Data* delta_signature_serialize(const DeltaSignature* sig) {
+  if (!sig)
+    return NULL;
 
   uint64_t total = sizeof(uint64_t) + sizeof(uint32_t) + sizeof(uint32_t) +
                    (uint64_t)sig->block_count * (sizeof(uint32_t) + sizeof(uint32_t));
 
-  uint8_t *buf = malloc((size_t)total);
-  if (!buf) return NULL;
+  uint8_t* buf = malloc((size_t)total);
+  if (!buf)
+    return NULL;
 
   size_t pos = 0;
   memcpy(buf + pos, &sig->file_size, sizeof(uint64_t));
@@ -82,15 +83,16 @@ Data *delta_signature_serialize(const DeltaSignature *sig) {
   return data_create(buf, (size_t)total);
 }
 
-DeltaSignature *delta_signature_deserialize(const Data *data) {
+DeltaSignature* delta_signature_deserialize(const Data* data) {
   if (!data || data->size < sizeof(uint64_t) + sizeof(uint32_t) + sizeof(uint32_t))
     return NULL;
 
-  const uint8_t *buf = (const uint8_t *)data->data;
+  const uint8_t* buf = (const uint8_t*)data->data;
   size_t pos = 0;
 
-  DeltaSignature *sig = malloc(sizeof(DeltaSignature));
-  if (!sig) return NULL;
+  DeltaSignature* sig = malloc(sizeof(DeltaSignature));
+  if (!sig)
+    return NULL;
 
   memcpy(&sig->file_size, buf + pos, sizeof(uint64_t));
   pos += sizeof(uint64_t);
@@ -122,31 +124,35 @@ DeltaSignature *delta_signature_deserialize(const Data *data) {
   return sig;
 }
 
-void delta_signature_destroy(DeltaSignature *sig) {
-  if (!sig) return;
+void delta_signature_destroy(DeltaSignature* sig) {
+  if (!sig)
+    return;
   free(sig->blocks);
   free(sig);
 }
 
-static bool ensure_capacity(DeltaInstruction **instrs, uint32_t *capacity,
-                             uint32_t count) {
-  if (count < *capacity) return true;
+static bool ensure_capacity(DeltaInstruction** instrs, uint32_t* capacity, uint32_t count) {
+  if (count < *capacity)
+    return true;
   uint32_t new_cap = *capacity * 2;
-  DeltaInstruction *tmp = realloc(*instrs, new_cap * sizeof(DeltaInstruction));
-  if (!tmp) return false;
+  DeltaInstruction* tmp = realloc(*instrs, new_cap * sizeof(DeltaInstruction));
+  if (!tmp)
+    return false;
   *instrs = tmp;
   *capacity = new_cap;
   return true;
 }
 
-static bool flush_literal(DeltaInstruction **instrs, uint32_t *capacity,
-                           uint32_t *count, const uint8_t *data,
-                           uint64_t start, uint64_t end) {
-  if (start >= end) return true;
+static bool flush_literal(DeltaInstruction** instrs, uint32_t* capacity, uint32_t* count,
+                          const uint8_t* data, uint64_t start, uint64_t end) {
+  if (start >= end)
+    return true;
   uint32_t lit_len = (uint32_t)(end - start);
-  if (!ensure_capacity(instrs, capacity, *count)) return false;
-  uint8_t *lit_data = malloc(lit_len);
-  if (!lit_data) return false;
+  if (!ensure_capacity(instrs, capacity, *count))
+    return false;
+  uint8_t* lit_data = malloc(lit_len);
+  if (!lit_data)
+    return false;
   memcpy(lit_data, data + start, lit_len);
   (*instrs)[*count].type = DELTA_INSTR_LITERAL;
   (*instrs)[*count].literal.data = lit_data;
@@ -155,17 +161,18 @@ static bool flush_literal(DeltaInstruction **instrs, uint32_t *capacity,
   return true;
 }
 
-Delta *delta_compute(const void *new_file_data, uint64_t new_file_size,
-                      const DeltaSignature *sig, uint32_t block_size) {
+Delta* delta_compute(const void* new_file_data, uint64_t new_file_size, const DeltaSignature* sig,
+                     uint32_t block_size) {
   if (!new_file_data || !sig || new_file_size == 0 || block_size == 0)
     return NULL;
 
-  const uint8_t *new_data = (const uint8_t *)new_file_data;
+  const uint8_t* new_data = (const uint8_t*)new_file_data;
 
   uint32_t capacity = 64;
   uint32_t count = 0;
-  DeltaInstruction *instrs = malloc(capacity * sizeof(DeltaInstruction));
-  if (!instrs) return NULL;
+  DeltaInstruction* instrs = malloc(capacity * sizeof(DeltaInstruction));
+  if (!instrs)
+    return NULL;
 
   uint64_t literal_start = 0;
   bool has_literal = false;
@@ -176,20 +183,17 @@ Delta *delta_compute(const void *new_file_data, uint64_t new_file_size,
   bool rolling_valid = false;
 
   while (i < new_file_size) {
-    uint32_t window_len = (uint32_t)((new_file_size - i < block_size)
-                                         ? (new_file_size - i)
-                                         : block_size);
+    uint32_t window_len =
+        (uint32_t)((new_file_size - i < block_size) ? (new_file_size - i) : block_size);
     bool full_window = (window_len == block_size);
 
     uint32_t adler;
     if (rolling_valid && full_window) {
       uint8_t old_byte = new_data[i - 1];
       uint8_t new_byte = new_data[i + block_size - 1];
-      s1 = (s1 + DELTA_ADLER32_MODULUS - old_byte + new_byte) %
-           DELTA_ADLER32_MODULUS;
+      s1 = (s1 + DELTA_ADLER32_MODULUS - old_byte + new_byte) % DELTA_ADLER32_MODULUS;
       s2 = (s2 + DELTA_ADLER32_MODULUS -
-            (uint32_t)((uint64_t)block_size * old_byte % DELTA_ADLER32_MODULUS) +
-            s1 - 1) %
+            (uint32_t)((uint64_t)block_size * old_byte % DELTA_ADLER32_MODULUS) + s1 - 1) %
            DELTA_ADLER32_MODULUS;
       adler = (s2 << 16) | s1;
     } else {
@@ -209,8 +213,7 @@ Delta *delta_compute(const void *new_file_data, uint64_t new_file_size,
         uint32_t xxh = delta_xxhash32(new_data + i, window_len);
         if (xxh == sig->blocks[j].xxhash) {
           if (has_literal) {
-            if (!flush_literal(&instrs, &capacity, &count, new_data,
-                               literal_start, i)) {
+            if (!flush_literal(&instrs, &capacity, &count, new_data, literal_start, i)) {
               free(instrs);
               return NULL;
             }
@@ -245,14 +248,13 @@ Delta *delta_compute(const void *new_file_data, uint64_t new_file_size,
   }
 
   if (has_literal) {
-    if (!flush_literal(&instrs, &capacity, &count, new_data,
-                       literal_start, new_file_size)) {
+    if (!flush_literal(&instrs, &capacity, &count, new_data, literal_start, new_file_size)) {
       free(instrs);
       return NULL;
     }
   }
 
-  Delta *delta = malloc(sizeof(Delta));
+  Delta* delta = malloc(sizeof(Delta));
   if (!delta) {
     for (uint32_t k = 0; k < count; k++) {
       if (instrs[k].type == DELTA_INSTR_LITERAL)
@@ -279,12 +281,14 @@ Delta *delta_compute(const void *new_file_data, uint64_t new_file_size,
   return delta;
 }
 
-Data *delta_serialize(const Delta *delta) {
-  if (!delta) return NULL;
+Data* delta_serialize(const Delta* delta) {
+  if (!delta)
+    return NULL;
 
   uint64_t total = sizeof(uint64_t) + sizeof(uint32_t) + delta->delta_size;
-  uint8_t *buf = malloc((size_t)total);
-  if (!buf) return NULL;
+  uint8_t* buf = malloc((size_t)total);
+  if (!buf)
+    return NULL;
 
   size_t pos = 0;
   memcpy(buf + pos, &delta->new_file_size, sizeof(uint64_t));
@@ -307,8 +311,7 @@ Data *delta_serialize(const Delta *delta) {
     } else {
       memcpy(buf + pos, &delta->instructions[i].literal.length, sizeof(uint32_t));
       pos += sizeof(uint32_t);
-      memcpy(buf + pos, delta->instructions[i].literal.data,
-             delta->instructions[i].literal.length);
+      memcpy(buf + pos, delta->instructions[i].literal.data, delta->instructions[i].literal.length);
       pos += delta->instructions[i].literal.length;
     }
   }
@@ -316,15 +319,16 @@ Data *delta_serialize(const Delta *delta) {
   return data_create(buf, (size_t)total);
 }
 
-Delta *delta_deserialize(const Data *data) {
+Delta* delta_deserialize(const Data* data) {
   if (!data || data->size < sizeof(uint64_t) + sizeof(uint32_t))
     return NULL;
 
-  const uint8_t *buf = (const uint8_t *)data->data;
+  const uint8_t* buf = (const uint8_t*)data->data;
   size_t pos = 0;
 
-  Delta *delta = malloc(sizeof(Delta));
-  if (!delta) return NULL;
+  Delta* delta = malloc(sizeof(Delta));
+  if (!delta)
+    return NULL;
 
   memcpy(&delta->new_file_size, buf + pos, sizeof(uint64_t));
   pos += sizeof(uint64_t);
@@ -408,21 +412,22 @@ Delta *delta_deserialize(const Data *data) {
   return delta;
 }
 
-void *delta_apply(const void *old_data, uint64_t old_size, const Delta *delta,
+void* delta_apply(const void* old_data, uint64_t old_size, const Delta* delta,
                   uint32_t block_size) {
-  if (!old_data || !delta) return NULL;
+  if (!old_data || !delta)
+    return NULL;
 
-  void *output = malloc((size_t)delta->new_file_size);
-  if (!output) return NULL;
+  void* output = malloc((size_t)delta->new_file_size);
+  if (!output)
+    return NULL;
 
-  uint8_t *out = (uint8_t *)output;
-  uint8_t *old = (uint8_t *)old_data;
+  uint8_t* out = (uint8_t*)output;
+  uint8_t* old = (uint8_t*)old_data;
   uint64_t out_pos = 0;
 
   for (uint32_t i = 0; i < delta->instruction_count; i++) {
     if (delta->instructions[i].type == DELTA_INSTR_BLOCK_MATCH) {
-      uint64_t src_offset = (uint64_t)delta->instructions[i].match.block_index *
-                             block_size;
+      uint64_t src_offset = (uint64_t)delta->instructions[i].match.block_index * block_size;
       src_offset += delta->instructions[i].match.block_offset;
       uint32_t len = delta->instructions[i].match.length;
 
@@ -447,8 +452,9 @@ void *delta_apply(const void *old_data, uint64_t old_size, const Delta *delta,
   return output;
 }
 
-void delta_destroy(Delta *delta) {
-  if (!delta) return;
+void delta_destroy(Delta* delta) {
+  if (!delta)
+    return;
   for (uint32_t i = 0; i < delta->instruction_count; i++) {
     if (delta->instructions[i].type == DELTA_INSTR_LITERAL)
       free(delta->instructions[i].literal.data);
@@ -469,8 +475,9 @@ bool delta_should_attempt(uint64_t old_size, uint64_t new_size, uint64_t max_fil
   return true;
 }
 
-bool delta_is_worthwhile(const Delta *delta, uint64_t new_file_size) {
-  if (!delta || delta->instruction_count == 0) return false;
+bool delta_is_worthwhile(const Delta* delta, uint64_t new_file_size) {
+  if (!delta || delta->instruction_count == 0)
+    return false;
 
   bool has_match = false;
   for (uint32_t i = 0; i < delta->instruction_count; i++) {
@@ -479,7 +486,8 @@ bool delta_is_worthwhile(const Delta *delta, uint64_t new_file_size) {
       break;
     }
   }
-  if (!has_match) return false;
+  if (!has_match)
+    return false;
 
   double ratio = (double)delta->delta_size / (double)new_file_size;
   return ratio < DELTA_FALLBACK_RATIO;

src/shared/delta.h

@@ -6,17 +6,17 @@
 #include <stdint.h>
 #include <stddef.h>
 
-#define DELTA_BLOCK_SIZE_DEFAULT  8192U
-#define DELTA_BLOCK_SIZE_MIN      1024U
-#define DELTA_BLOCK_SIZE_MAX      65536U
-#define DELTA_MIN_FILE_SIZE       16384ULL
-#define DELTA_MAX_FILE_SIZE       (256ULL * 1024 * 1024)
-#define DELTA_MAX_SIZE_RATIO      10.0
-#define DELTA_FALLBACK_RATIO      0.7
-#define DELTA_ADLER32_MODULUS     65521U
+#define DELTA_BLOCK_SIZE_DEFAULT 8192U
+#define DELTA_BLOCK_SIZE_MIN 1024U
+#define DELTA_BLOCK_SIZE_MAX 65536U
+#define DELTA_MIN_FILE_SIZE 16384ULL
+#define DELTA_MAX_FILE_SIZE (256ULL * 1024 * 1024)
+#define DELTA_MAX_SIZE_RATIO 10.0
+#define DELTA_FALLBACK_RATIO 0.7
+#define DELTA_ADLER32_MODULUS 65521U
 
-#define DELTA_OP_BLOCK_MATCH  0x01
-#define DELTA_OP_LITERAL      0x02
+#define DELTA_OP_BLOCK_MATCH 0x01
+#define DELTA_OP_LITERAL 0x02
 
 typedef struct {
   uint32_t adler32;
@@ -27,13 +27,10 @@ typedef struct {
   uint64_t file_size;
   uint32_t block_size;
   uint32_t block_count;
-  DeltaBlockSig *blocks;
+  DeltaBlockSig* blocks;
 } DeltaSignature;
 
-typedef enum {
-  DELTA_INSTR_BLOCK_MATCH = 0x01,
-  DELTA_INSTR_LITERAL     = 0x02
-} DeltaInstrType;
+typedef enum { DELTA_INSTR_BLOCK_MATCH = 0x01, DELTA_INSTR_LITERAL = 0x02 } DeltaInstrType;
 
 typedef struct {
   DeltaInstrType type;
@@ -44,7 +41,7 @@ typedef struct {
       uint32_t length;
     } match;
     struct {
-      uint8_t *data;
+      uint8_t* data;
       uint32_t length;
     } literal;
   };
@@ -53,29 +50,27 @@ typedef struct {
 typedef struct {
   uint64_t new_file_size;
   uint32_t instruction_count;
-  DeltaInstruction *instructions;
+  DeltaInstruction* instructions;
   uint64_t delta_size;
 } Delta;
 
-DeltaSignature *delta_signature_create(const void *old_file_data,
-                                        uint64_t old_file_size,
-                                        uint32_t block_size);
-Data *delta_signature_serialize(const DeltaSignature *sig);
-DeltaSignature *delta_signature_deserialize(const Data *data);
-void delta_signature_destroy(DeltaSignature *sig);
+DeltaSignature* delta_signature_create(const void* old_file_data, uint64_t old_file_size,
+                                       uint32_t block_size);
+Data* delta_signature_serialize(const DeltaSignature* sig);
+DeltaSignature* delta_signature_deserialize(const Data* data);
+void delta_signature_destroy(DeltaSignature* sig);
 
-Delta *delta_compute(const void *new_file_data, uint64_t new_file_size,
-                      const DeltaSignature *sig, uint32_t block_size);
-Data *delta_serialize(const Delta *delta);
-Delta *delta_deserialize(const Data *data);
-void *delta_apply(const void *old_data, uint64_t old_size, const Delta *delta,
-                  uint32_t block_size);
-void delta_destroy(Delta *delta);
+Delta* delta_compute(const void* new_file_data, uint64_t new_file_size, const DeltaSignature* sig,
+                     uint32_t block_size);
+Data* delta_serialize(const Delta* delta);
+Delta* delta_deserialize(const Data* data);
+void* delta_apply(const void* old_data, uint64_t old_size, const Delta* delta, uint32_t block_size);
+void delta_destroy(Delta* delta);
 
 bool delta_should_attempt(uint64_t old_size, uint64_t new_size, uint64_t max_file_size);
-bool delta_is_worthwhile(const Delta *delta, uint64_t new_file_size);
+bool delta_is_worthwhile(const Delta* delta, uint64_t new_file_size);
 
-uint32_t delta_adler32(const void *data, uint32_t len);
-uint32_t delta_xxhash32(const void *data, uint32_t len);
+uint32_t delta_adler32(const void* data, uint32_t len);
+uint32_t delta_xxhash32(const void* data, uint32_t len);
 
 #endif

src/shared/file.c

@@ -137,33 +137,50 @@ bool file_save_to_disk(const char* root_directory, File* file) {
   return ok;
 }
 
-static void *old_data_from_path(const char *full_path, unsigned long long old_size) {
-  void *data = malloc((size_t)old_size);
-  if (!data) return NULL;
-  FILE *fp = fopen(full_path, "rb");
-  if (!fp) { free(data); return NULL; }
+static void* old_data_from_path(const char* full_path, unsigned long long old_size) {
+  void* data = malloc((size_t)old_size);
+  if (!data)
+    return NULL;
+  FILE* fp = fopen(full_path, "rb");
+  if (!fp) {
+    free(data);
+    return NULL;
+  }
   size_t nread = fread(data, 1, (size_t)old_size, fp);
   fclose(fp);
-  if (nread != (size_t)old_size) { free(data); return NULL; }
+  if (nread != (size_t)old_size) {
+    free(data);
+    return NULL;
+  }
   return data;
 }
 
-static File *receive_delta_file(int fd, const Config *config, const char *check_path,
-                                 void *old_data, unsigned long long old_size) {
-  if (!old_data) return NULL;
+static File* receive_delta_file(int fd, const Config* config, const char* check_path,
+                                void* old_data, unsigned long long old_size) {
+  if (!old_data)
+    return NULL;
 
-  DeltaSignature *sig = delta_signature_create(old_data, old_size,
-                                                config->delta_block_size);
-  if (!sig) { free(old_data); return NULL; }
+  DeltaSignature* sig = delta_signature_create(old_data, old_size, config->delta_block_size);
+  if (!sig) {
+    free(old_data);
+    return NULL;
+  }
 
-  Data *sig_data = delta_signature_serialize(sig);
-  if (!sig_data) { delta_signature_destroy(sig); free(old_data); return NULL; }
+  Data* sig_data = delta_signature_serialize(sig);
+  if (!sig_data) {
+    delta_signature_destroy(sig);
+    free(old_data);
+    return NULL;
+  }
 
-  bool sig_sent = send_status(fd, STATUS_DELTA_SIGNATURE) &&
-                  send_data(fd, sig_data);
+  bool sig_sent = send_status(fd, STATUS_DELTA_SIGNATURE) && send_data(fd, sig_data);
   data_destroy(sig_data);
 
-  if (!sig_sent) { delta_signature_destroy(sig); free(old_data); return NULL; }
+  if (!sig_sent) {
+    delta_signature_destroy(sig);
+    free(old_data);
+    return NULL;
+  }
 
   Status resp;
   if (!receive_status(fd, &resp)) {
@@ -173,7 +190,7 @@ static File *receive_delta_file(int fd, const Config *config, const char *check_
   }
 
   if (resp == STATUS_DELTA_DATA) {
-    Data *delta_data = receive_data(fd);
+    Data* delta_data = receive_data(fd);
     if (!delta_data) {
       delta_signature_destroy(sig);
       free(old_data);
@@ -181,7 +198,7 @@ static File *receive_delta_file(int fd, const Config *config, const char *check_
       return NULL;
     }
 
-    Data *raw_delta = delta_data;
+    Data* raw_delta = delta_data;
     if (config->use_compression) {
       raw_delta = data_decompress(delta_data);
       data_destroy(delta_data);
@@ -193,7 +210,7 @@ static File *receive_delta_file(int fd, const Config *config, const char *check_
       }
     }
 
-    Delta *delta = delta_deserialize(raw_delta);
+    Delta* delta = delta_deserialize(raw_delta);
     data_destroy(raw_delta);
     if (!delta) {
       free(old_data);
@@ -202,8 +219,7 @@ static File *receive_delta_file(int fd, const Config *config, const char *check_
       return NULL;
     }
 
-    void *new_data = delta_apply(old_data, old_size, delta,
-                                  config->delta_block_size);
+    void* new_data = delta_apply(old_data, old_size, delta, config->delta_block_size);
     uint64_t new_size = delta->new_file_size;
     delta_destroy(delta);
 
@@ -214,7 +230,7 @@ static File *receive_delta_file(int fd, const Config *config, const char *check_
       return NULL;
     }
 
-    File *file = file_create(check_path);
+    File* file = file_create(check_path);
     if (!file) {
       free(new_data);
       free(old_data);
@@ -248,16 +264,23 @@ static File *receive_delta_file(int fd, const Config *config, const char *check_
     delta_signature_destroy(sig);
     free(old_data);
 
-    File *file = file_create(check_path);
-    if (!file) { send_status(fd, STATUS_ERROR); return NULL; }
+    File* file = file_create(check_path);
+    if (!file) {
+      send_status(fd, STATUS_ERROR);
+      return NULL;
+    }
 
     if (config->use_metadata) {
       int meta_ok = 1;
       file->metadata = metadata_receive(fd, &meta_ok);
-      if (!meta_ok) { file_destroy(file); send_status(fd, STATUS_ERROR); return NULL; }
+      if (!meta_ok) {
+        file_destroy(file);
+        send_status(fd, STATUS_ERROR);
+        return NULL;
+      }
     }
 
-    Data *file_data = receive_data(fd);
+    Data* file_data = receive_data(fd);
     if (file_data == NULL) {
       file_destroy(file);
       send_status(fd, STATUS_ERROR);
@@ -265,9 +288,13 @@ static File *receive_delta_file(int fd, const Config *config, const char *check_
     }
 
     if (config->use_compression) {
-      Data *uncompressed = data_decompress(file_data);
+      Data* uncompressed = data_decompress(file_data);
       data_destroy(file_data);
-      if (uncompressed == NULL) { file_destroy(file); send_status(fd, STATUS_ERROR); return NULL; }
+      if (uncompressed == NULL) {
+        file_destroy(file);
+        send_status(fd, STATUS_ERROR);
+        return NULL;
+      }
       file_data = uncompressed;
     }
 
@@ -284,7 +311,10 @@ static File *receive_delta_file(int fd, const Config *config, const char *check_
 File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   *skipped = false;
   char* check_path = receive_str(fd);
-  if (check_path == NULL) { send_status(fd, STATUS_ERROR); return NULL; }
+  if (check_path == NULL) {
+    send_status(fd, STATUS_ERROR);
+    return NULL;
+  }
 
   unsigned long long check_size;
   long long check_mtime;
@@ -300,12 +330,15 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   bool has_old_file = (full_path && stat(full_path, &st) == 0);
   unsigned long long old_size = has_old_file ? (unsigned long long)st.st_size : 0;
 
-  bool match = has_old_file &&
-               (unsigned long long)st.st_size == check_size &&
+  bool match = has_old_file && (unsigned long long)st.st_size == check_size &&
                (long long)st.st_mtime == check_mtime;
 
   if (match) {
-    if (!send_status(fd, STATUS_OK)) { free(full_path); free(check_path); return NULL; }
+    if (!send_status(fd, STATUS_OK)) {
+      free(full_path);
+      free(check_path);
+      return NULL;
+    }
     free(full_path);
     free(check_path);
     *skipped = true;
@@ -316,9 +349,8 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
                    delta_should_attempt(old_size, check_size, config->delta_max_file_size);
 
   if (try_delta) {
-    void *old_data = old_data_from_path(full_path, old_size);
-    File *delta_file = receive_delta_file(fd, config, check_path,
-                                           old_data, old_size);
+    void* old_data = old_data_from_path(full_path, old_size);
+    File* delta_file = receive_delta_file(fd, config, check_path, old_data, old_size);
     if (delta_file) {
       free(full_path);
       free(check_path);
@@ -338,7 +370,10 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   File* file = file_create(check_path);
   free(check_path);
   free(full_path);
-  if (file == NULL) { send_status(fd, STATUS_ERROR); return NULL; }
+  if (file == NULL) {
+    send_status(fd, STATUS_ERROR);
+    return NULL;
+  }
 
   if (config->use_metadata) {
     int meta_ok = 1;
@@ -398,10 +433,13 @@ bool to_disk(const char* path, const void* data, unsigned long long data_size) {
   return true;
 }
 
-bool file_send_sendfile(File *file, int file_descriptor, bool use_metadata, int compression_level, bool send_path) {
+bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int compression_level,
+                        bool send_path) {
   (void)compression_level;
-  if (send_path && !send_str(file_descriptor, file->path)) return false;
-  if (use_metadata && !metadata_send(file_descriptor, file->metadata)) return false;
+  if (send_path && !send_str(file_descriptor, file->path))
+    return false;
+  if (use_metadata && !metadata_send(file_descriptor, file->metadata))
+    return false;
 
   int fd = open(file->path, O_RDONLY);
   if (fd == -1) {

src/shared/file.h

@@ -26,8 +26,8 @@ bool file_load_data(File* file);
 File* file_receive(const Config* config, int file_descriptor);
 bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
                             int compression_level, bool send_path);
-bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata,
-                        int compression_level, bool send_path);
+bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, int compression_level,
+                        bool send_path);
 size_t file_content_to_buffer(File* file);
 FileMetadata* file_metadata_create(const struct stat* stats);
 void file_metadata_destroy(void* metadata);