fix: reformat codebase and fix const-correctness for CI lint

- Reformat all C/H files to match .clang-format (LLVM style)
- Fix 26 cppcheck const-correctness warnings (constParameterPointer,
  constVariablePointer, constVariable)
- Update function declarations in headers to match const parameters

src/shared/array_list.c

@@ -3,14 +3,14 @@
 #include <stdlib.h>
 #include <string.h>
 
-ArrayList *array_list_create(void (*item_destroyer)(void *item)) {
-  ArrayList *list = (ArrayList *)malloc(sizeof(ArrayList));
+ArrayList* array_list_create(void (*item_destroyer)(void* item)) {
+  ArrayList* list = (ArrayList*)malloc(sizeof(ArrayList));
   if (list == NULL) {
     perror("ERROR: Could not allocate memory for array list struct");
     return NULL;
   }
 
-  list->items = malloc(INITIAL_ARRAY_SIZE * sizeof(void *));
+  list->items = malloc(INITIAL_ARRAY_SIZE * sizeof(void*));
   if (list->items == NULL) {
     free(list);
     return NULL;
@@ -21,7 +21,7 @@ ArrayList *array_list_create(void (*item_destroyer)(void *item)) {
   return list;
 }
 
-void array_list_delete(ArrayList *array_list) {
+void array_list_delete(ArrayList* array_list) {
   if (array_list == NULL)
     return;
   if (array_list->item_destroyer != NULL) {
@@ -34,12 +34,13 @@ void array_list_delete(ArrayList *array_list) {
   free(array_list);
 }
 
-bool array_list_extend(ArrayList *array_list) {
-  if (array_list == NULL) return false;
+bool array_list_extend(ArrayList* array_list) {
+  if (array_list == NULL)
+    return false;
   int new_capacity = array_list->capacity * 2;
   if (new_capacity == 0)
     new_capacity = INITIAL_ARRAY_SIZE;
-  void *new_items = realloc(array_list->items, new_capacity * sizeof(void *));
+  void* new_items = realloc(array_list->items, new_capacity * sizeof(void*));
   if (new_items == NULL) {
     perror("ERROR: Could not reallocate memory for array list items");
     return false;
@@ -49,8 +50,9 @@ bool array_list_extend(ArrayList *array_list) {
   return true;
 }
 
-bool array_list_add(ArrayList *array_list, void *item) {
-  if (array_list == NULL) return false;
+bool array_list_add(ArrayList* array_list, void* item) {
+  if (array_list == NULL)
+    return false;
   if (array_list->capacity == array_list->size) {
     if (!array_list_extend(array_list))
       return false;
@@ -60,15 +62,15 @@ bool array_list_add(ArrayList *array_list, void *item) {
   return true;
 }
 
-void **array_list_to_array(ArrayList *array_list) {
+void** array_list_to_array(const ArrayList* array_list) {
   if (array_list == NULL) {
     return NULL;
   }
-  void **array = malloc(array_list->size * sizeof(void *));
+  void** array = malloc(array_list->size * sizeof(void*));
   if (array == NULL) {
     perror("Could not malloc space for array from array list!");
     return NULL;
   }
-  memcpy(array, array_list->items, array_list->size * sizeof(void *));
+  memcpy(array, array_list->items, array_list->size * sizeof(void*));
   return array;
 }

src/shared/array_list.h

@@ -6,16 +6,16 @@
 #define INITIAL_ARRAY_SIZE 100
 
 typedef struct ArrayList {
-  void **items;
+  void** items;
   int size;
   int capacity;
-  void (*item_destroyer)(void *item);
+  void (*item_destroyer)(void* item);
 } ArrayList;
 
-ArrayList *array_list_create(void (*item_destroyer)(void *item));
-void array_list_delete(ArrayList *array_list);
-bool array_list_extend(ArrayList *array_list);
-bool array_list_add(ArrayList *array_list, void *item);
-void **array_list_to_array(ArrayList *array_list);
+ArrayList* array_list_create(void (*item_destroyer)(void* item));
+void array_list_delete(ArrayList* array_list);
+bool array_list_extend(ArrayList* array_list);
+bool array_list_add(ArrayList* array_list, void* item);
+void** array_list_to_array(const ArrayList* array_list);
 
 #endif

src/shared/chunk.c

@@ -12,14 +12,14 @@
 #include "metadata.h"
 #include "protocol.h"
 
-Chunk *chunk_create(File **items, int element_count) {
-  Chunk *chunk = (Chunk *)malloc(sizeof(Chunk));
+Chunk* chunk_create(File** items, int element_count) {
+  Chunk* chunk = (Chunk*)malloc(sizeof(Chunk));
   if (chunk == NULL) {
     perror("ERROR: Could not allocate memory for chunk structure");
     return NULL;
   }
 
-  chunk->items = (File **)malloc(element_count * sizeof(File *));
+  chunk->items = (File**)malloc(element_count * sizeof(File*));
   if (chunk->items == NULL) {
     free(chunk);
     return NULL;
@@ -32,11 +32,11 @@ Chunk *chunk_create(File **items, int element_count) {
   return chunk;
 }
 
-void chunk_destroy(void *item) {
+void chunk_destroy(void* item) {
   if (item == NULL) {
     return;
   }
-  Chunk *chunk = (Chunk *)item;
+  Chunk* chunk = (Chunk*)item;
   for (int i = 0; i < chunk->element_count; ++i) {
     if (chunk->items[i] != NULL) {
       file_destroy(chunk->items[i]);
@@ -46,26 +46,25 @@ void chunk_destroy(void *item) {
   free(chunk);
 }
 
-static unsigned long long per_file_serialize_size(File *file, bool use_metadata) {
+static unsigned long long per_file_serialize_size(File* file, bool use_metadata) {
   return sizeof(size_t) + strlen(file->path) +
          (use_metadata ? sizeof(int) + (file->metadata ? FILE_METADATA_WIRE_SIZE : 0) : 0) +
          sizeof(size_t) + file->data->size;
 }
 
-Data *chunk_serialize(Chunk *chunk, bool use_metadata) {
+Data* chunk_serialize(Chunk* chunk, bool use_metadata) {
   unsigned long long data_size = 0;
   for (int i = 0; i < chunk->element_count; i++) {
     data_size += per_file_serialize_size(chunk->items[i], use_metadata);
   }
-  Data *data = data_create_empty(data_size);
+  Data* data = data_create_empty(data_size);
   if (data == NULL) {
-    log_message(LOG_LEVEL_ERROR,
-                "Could not allocate memory for chunk serialization");
+    log_message(LOG_LEVEL_ERROR, "Could not allocate memory for chunk serialization");
     return NULL;
   }
-  char *data_pointer = data->data;
+  char* data_pointer = data->data;
   for (int i = 0; i < chunk->element_count; i++) {
-    File *file = chunk->items[i];
+    File* file = chunk->items[i];
     size_t path_len = strlen(file->path);
     memcpy(data_pointer, &path_len, sizeof(size_t));
     data_pointer += sizeof(size_t);
@@ -84,9 +83,9 @@ Data *chunk_serialize(Chunk *chunk, bool use_metadata) {
   return data;
 }
 
-Chunk *chunk_deserialize(Data *data, bool use_metadata) {
-  ArrayList *files = array_list_create(file_destroy);
-  char *data_pointer = data->data;
+Chunk* chunk_deserialize(Data* data, bool use_metadata) {
+  ArrayList* files = array_list_create(file_destroy);
+  char* data_pointer = data->data;
   size_t remaining_size = data->size;
 
   while (remaining_size > 0) {
@@ -96,7 +95,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
       return NULL;
     }
 
-    size_t path_len = *(size_t *)data_pointer;
+    size_t path_len = *(size_t*)data_pointer;
     data_pointer += sizeof(size_t);
     remaining_size -= sizeof(size_t);
 
@@ -106,7 +105,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
       return NULL;
     }
 
-    char *path = malloc(path_len + 1);
+    char* path = malloc(path_len + 1);
     if (path == NULL) {
       perror("Could not allocate memory for file path");
       array_list_delete(files);
@@ -117,7 +116,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
     data_pointer += path_len;
     remaining_size -= path_len;
 
-    File *file = file_create(path);
+    File* file = file_create(path);
     free(path);
 
     if (use_metadata) {
@@ -133,7 +132,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
       return NULL;
     }
 
-    size_t file_data_size = *(size_t *)data_pointer;
+    size_t file_data_size = *(size_t*)data_pointer;
     data_pointer += sizeof(size_t);
     remaining_size -= sizeof(size_t);
 
@@ -143,7 +142,7 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
       return NULL;
     }
 
-    void *file_data = malloc(file_data_size);
+    void* file_data = malloc(file_data_size);
     if (file_data == NULL) {
       perror("Could not allocate memory for file data");
       array_list_delete(files);
@@ -158,8 +157,8 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
     array_list_add(files, file);
   }
 
-  File **file_array = (File **)array_list_to_array(files);
-  Chunk *chunk = chunk_create(file_array, files->size);
+  File** file_array = (File**)array_list_to_array(files);
+  Chunk* chunk = chunk_create(file_array, files->size);
 
   free(file_array);
   files->item_destroyer = NULL;
@@ -168,24 +167,26 @@ Chunk *chunk_deserialize(Data *data, bool use_metadata) {
   return chunk;
 }
 
-Data *chunk_compress(Chunk *chunk, int compression_level, bool use_metadata) {
+Data* chunk_compress(Chunk* chunk, int compression_level, bool use_metadata) {
   log_message(LOG_LEVEL_DEBUG, "Starting to compress chunk");
-  Data *serialized = chunk_serialize(chunk, use_metadata);
-  if (serialized == NULL) return NULL;
-  Data *compressed = data_compress(serialized, compression_level);
+  Data* serialized = chunk_serialize(chunk, use_metadata);
+  if (serialized == NULL)
+    return NULL;
+  Data* compressed = data_compress(serialized, compression_level);
   data_destroy(serialized);
-  if (compressed == NULL) return NULL;
+  if (compressed == NULL)
+    return NULL;
   log_message(LOG_LEVEL_DEBUG, "Chunk successfully compressed");
   return compressed;
 }
 
-Chunk *receive_chunk_data(int fd, Config *config) {
-  Data *chunk_data = receive_data(fd);
+Chunk* receive_chunk_data(int fd, const Config* config) {
+  Data* chunk_data = receive_data(fd);
   if (chunk_data == NULL) {
     log_message(LOG_LEVEL_ERROR, "Failed to receive chunk data");
     return NULL;
   }
-  Data *data_to_process = chunk_data;
+  Data* data_to_process = chunk_data;
   if (config->use_compression) {
     data_to_process = data_decompress(chunk_data);
     data_destroy(chunk_data);
@@ -194,12 +195,9 @@ Chunk *receive_chunk_data(int fd, Config *config) {
       return NULL;
     }
   }
-  Chunk *chunk = chunk_deserialize(data_to_process, config->use_metadata);
+  Chunk* chunk = chunk_deserialize(data_to_process, config->use_metadata);
   data_destroy(data_to_process);
   if (chunk == NULL)
     log_message(LOG_LEVEL_ERROR, "Failed to deserialize chunk, skipping");
   return chunk;
 }
-
-
-

src/shared/chunk.h

@@ -10,15 +10,15 @@
 #define DESIRED_CHUNK_SIZE (10 * 1024 * 1024)
 
 typedef struct {
-  File **items;
+  File** items;
   int element_count;
 } Chunk;
 
-Chunk *chunk_create(File **items, int element_count);
-void chunk_destroy(void *chunk);
-Data *chunk_serialize(Chunk *chunk, bool use_metadata);
-Chunk *chunk_deserialize(Data *data, bool use_metadata);
-Data *chunk_compress(Chunk *chunk, int compression_level, bool use_metadata);
-Chunk *receive_chunk_data(int fd, Config *config);
+Chunk* chunk_create(File** items, int element_count);
+void chunk_destroy(void* chunk);
+Data* chunk_serialize(Chunk* chunk, bool use_metadata);
+Chunk* chunk_deserialize(Data* data, bool use_metadata);
+Data* chunk_compress(Chunk* chunk, int compression_level, bool use_metadata);
+Chunk* receive_chunk_data(int fd, const Config* config);
 
 #endif

src/shared/compression.c

@@ -6,14 +6,15 @@
 
 #define INITIAL_DECOMPRESS_BUF_SIZE (1024 * 1024)
 
-Data *data_compress(Data *data_to_compress, int compression_level) {
+Data* data_compress(Data* data_to_compress, int compression_level) {
   (void)compression_level;
   log_message(LOG_LEVEL_DEBUG, "Starting to compress data");
   size_t dst_size = ZSTD_compressBound(data_to_compress->size);
-  Data *compressed_data = data_create_empty(dst_size);
-  if (compressed_data == NULL) return NULL;
+  Data* compressed_data = data_create_empty(dst_size);
+  if (compressed_data == NULL)
+    return NULL;
 
-  ZSTD_CCtx *cctx = ZSTD_createCCtx();
+  ZSTD_CCtx* cctx = ZSTD_createCCtx();
   if (!cctx) {
     log_message(LOG_LEVEL_ERROR, "Failed to create ZSTD compression context");
     data_destroy(compressed_data);
@@ -27,8 +28,7 @@ Data *data_compress(Data *data_to_compress, int compression_level) {
   do {
     ret = ZSTD_compressStream2(cctx, &output, &input, ZSTD_e_end);
     if (ZSTD_isError(ret)) {
-      log_message(LOG_LEVEL_ERROR, "Compression failed: %s",
-                  ZSTD_getErrorName(ret));
+      log_message(LOG_LEVEL_ERROR, "Compression failed: %s", ZSTD_getErrorName(ret));
       ZSTD_freeCCtx(cctx);
       data_destroy(compressed_data);
       return NULL;
@@ -43,27 +43,25 @@ Data *data_compress(Data *data_to_compress, int compression_level) {
   return compressed_data;
 }
 
-Data *data_decompress(Data *compressed_data) {
+Data* data_decompress(Data* compressed_data) {
   log_message(LOG_LEVEL_DEBUG, "Start to decompress data");
-  unsigned long long dst_size = ZSTD_getFrameContentSize(
-      compressed_data->data, compressed_data->size);
+  unsigned long long dst_size =
+      ZSTD_getFrameContentSize(compressed_data->data, compressed_data->size);
   if (ZSTD_isError(dst_size)) {
     log_message(LOG_LEVEL_ERROR, "Failed to get decompressed size: %s",
                 ZSTD_getErrorName(dst_size));
     return NULL;
   }
 
-  ZSTD_DCtx *dctx = ZSTD_createDCtx();
+  ZSTD_DCtx* dctx = ZSTD_createDCtx();
   if (!dctx) {
-    log_message(LOG_LEVEL_ERROR,
-                "Failed to create ZSTD decompression context");
+    log_message(LOG_LEVEL_ERROR, "Failed to create ZSTD decompression context");
     return NULL;
   }
 
-  size_t buf_size = (!ZSTD_isError(dst_size) && dst_size > 0)
-                        ? (size_t)dst_size
-                        : INITIAL_DECOMPRESS_BUF_SIZE;
-  Data *uncompressed_data = data_create_empty(buf_size);
+  size_t buf_size =
+      (!ZSTD_isError(dst_size) && dst_size > 0) ? (size_t)dst_size : INITIAL_DECOMPRESS_BUF_SIZE;
+  Data* uncompressed_data = data_create_empty(buf_size);
   if (!uncompressed_data) {
     log_message(LOG_LEVEL_ERROR, "Failed to allocate decompression buffer");
     ZSTD_freeDCtx(dctx);
@@ -77,15 +75,14 @@ Data *data_decompress(Data *compressed_data) {
   do {
     ret = ZSTD_decompressStream(dctx, &output, &input);
     if (ZSTD_isError(ret)) {
-      log_message(LOG_LEVEL_ERROR, "Decompression failed: %s",
-                  ZSTD_getErrorName(ret));
+      log_message(LOG_LEVEL_ERROR, "Decompression failed: %s", ZSTD_getErrorName(ret));
       ZSTD_freeDCtx(dctx);
       data_destroy(uncompressed_data);
       return NULL;
     }
     if (ret > 0 && output.pos == output.size) {
       buf_size *= 2;
-      void *new_data = realloc(uncompressed_data->data, buf_size);
+      void* new_data = realloc(uncompressed_data->data, buf_size);
       if (!new_data) {
         log_message(LOG_LEVEL_ERROR, "Failed to grow decompression buffer");
         ZSTD_freeDCtx(dctx);

src/shared/compression.h

@@ -3,7 +3,7 @@
 
 #include "data.h"
 
-Data *data_compress(Data *data_to_compress, int compression_level);
-Data *data_decompress(Data *compressed_data);
+Data* data_compress(Data* data_to_compress, int compression_level);
+Data* data_decompress(Data* compressed_data);
 
 #endif

src/shared/config.c

@@ -7,14 +7,12 @@
 #include <stdlib.h>
 #include <string.h>
 
-Config *config_create(char *version, char *send_directory,
-                      char *receive_directory, bool save_to_disk,
-                      bool use_multithreading, bool use_chunk_serialization,
-                       bool use_compression, bool use_metadata,
-                       int compression_level, bool use_sendfile,
-                       unsigned long long chunk_size) {
+Config* config_create(char* version, char* send_directory, char* receive_directory,
+                      bool save_to_disk, bool use_multithreading, bool use_chunk_serialization,
+                      bool use_compression, bool use_metadata, int compression_level,
+                      bool use_sendfile, unsigned long long chunk_size) {
 
-  Config *config = malloc(sizeof(Config));
+  Config* config = malloc(sizeof(Config));
   config->version = version;
   config->send_directory = send_directory;
   config->receive_root_directory = receive_directory;
@@ -46,28 +44,33 @@ Config *config_create(char *version, char *send_directory,
   return config;
 }
 
-bool is_remote_dest(const char *s) {
-  if (s == NULL) return false;
-  const char *colon = strchr(s, ':');
-  if (colon == NULL) return false;
-  if (colon == s) return false;
-  for (const char *p = s; p < colon; p++) {
-    if (*p == '/') return false;
+bool is_remote_dest(const char* s) {
+  if (s == NULL)
+    return false;
+  const char* colon = strchr(s, ':');
+  if (colon == NULL)
+    return false;
+  if (colon == s)
+    return false;
+  for (const char* p = s; p < colon; p++) {
+    if (*p == '/')
+      return false;
   }
   return true;
 }
 
-void config_parse_ssh_dest(Config *config) {
-  if (!is_remote_dest(config->receive_root_directory)) return;
+void config_parse_ssh_dest(Config* config) {
+  if (!is_remote_dest(config->receive_root_directory))
+    return;
   config->transport = TRANSPORT_SSH;
   config->ssh_destination = str_dup(config->receive_root_directory);
-  char *colon = strchr(config->receive_root_directory, ':');
-  char *path = str_dup(colon + 1);
+  const char* colon = strchr(config->receive_root_directory, ':');
+  char* path = str_dup(colon + 1);
   free(config->receive_root_directory);
   config->receive_root_directory = path;
 }
 
-void config_delete(Config *config) {
+void config_delete(Config* config) {
   free(config->version);
   free(config->send_directory);
   free(config->receive_root_directory);
@@ -84,22 +87,36 @@ void config_delete(Config *config) {
   free(config);
 }
 
-bool config_send(int file_descriptor, 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;
+bool config_send(int file_descriptor, 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;
   Status status;
-  if (!receive_status(file_descriptor, &status)) return false;
+  if (!receive_status(file_descriptor, &status))
+    return false;
   if (status != STATUS_OK) {
     log_message(LOG_LEVEL_ERROR, "Error transmitting config");
     return false;
@@ -107,43 +124,66 @@ bool config_send(int file_descriptor, Config *config) {
   return true;
 }
 
-Config *config_receive(int file_descriptor) {
-  Config *config = (Config *)malloc(sizeof(Config));
-  if (config == NULL) return NULL;
+Config* config_receive(int file_descriptor) {
+  Config* config = (Config*)malloc(sizeof(Config));
+  if (config == NULL)
+    return NULL;
   config->version = receive_str(file_descriptor);
-  if (!config->version) { free(config); return NULL; }
+  if (!config->version) {
+    free(config);
+    return NULL;
+  }
   if (strcmp(config->version, PROTOCOL_VERSION) != 0) {
-    fprintf(stderr, "Protocol version mismatch: client=%s, server=%s\n",
-            config->version, PROTOCOL_VERSION);
+    fprintf(stderr, "Protocol version mismatch: client=%s, server=%s\n", config->version,
+            PROTOCOL_VERSION);
     free(config->version);
     free(config);
     send_status(file_descriptor, STATUS_ERROR);
     return NULL;
   }
   config->send_directory = receive_str(file_descriptor);
-  if (!config->send_directory) { free(config->version); free(config); return NULL; }
+  if (!config->send_directory) {
+    free(config->version);
+    free(config);
+    return NULL;
+  }
   config->receive_root_directory = receive_str(file_descriptor);
-  if (!config->receive_root_directory) { free(config->version); free(config->send_directory); free(config); return NULL; }
+  if (!config->receive_root_directory) {
+    free(config->version);
+    free(config->send_directory);
+    free(config);
+    return NULL;
+  }
   int tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->save_to_disk = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->use_multithreading = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->use_chunk_serialization = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->use_compression = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->use_metadata = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->compression_level = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->chunk_size = (unsigned long long)tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->use_sendfile = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->use_delete = tmp;
-  if (!receive_int(file_descriptor, &tmp)) goto error;
+  if (!receive_int(file_descriptor, &tmp))
+    goto error;
   config->use_incremental = tmp;
   config->show_progress = false;
   config->dry_run = false;
@@ -160,7 +200,8 @@ Config *config_receive(int file_descriptor) {
   config->tls_cert = NULL;
   config->tls_key = NULL;
   config->tls_ca = NULL;
-  if (!send_status(file_descriptor, STATUS_OK)) goto error;
+  if (!send_status(file_descriptor, STATUS_OK))
+    goto error;
   return config;
 
 error:

src/shared/config.h

@@ -3,15 +3,12 @@
 
 #include <stdbool.h>
 
-typedef enum {
-  TRANSPORT_TCP,
-  TRANSPORT_SSH
-} TransportType;
+typedef enum { TRANSPORT_TCP, TRANSPORT_SSH } TransportType;
 
 typedef struct Config {
-  char *version;
-  char *send_directory;
-  char *receive_root_directory;
+  char* version;
+  char* send_directory;
+  char* receive_root_directory;
   bool save_to_disk;
   bool use_multithreading;
   bool use_chunk_serialization;
@@ -25,33 +22,31 @@ typedef struct Config {
   unsigned long long chunk_size;
   int ssh_port;
   TransportType transport;
-  char *ssh_destination;
-  char **exclude_patterns;
+  char* ssh_destination;
+  char** exclude_patterns;
   int exclude_count;
-  char **include_patterns;
+  char** include_patterns;
   int include_count;
   unsigned long long max_size;
   unsigned long long min_size;
   bool use_incremental;
   bool use_tls;
-  char *tls_cert;
-  char *tls_key;
-  char *tls_ca;
+  char* tls_cert;
+  char* tls_key;
+  char* tls_ca;
 } Config;
 
 #define PROTOCOL_VERSION "1.1.0"
 #define DEFAULT_CHUNK_SIZE (10 * 1024 * 1024)
 
-Config *config_create(char *version, char *send_directory,
-                      char *receive_directory, bool save_to_disk,
-                      bool use_multithreading, bool use_chunk_serialization,
-                       bool use_compression, bool use_metadata,
-                       int compression_level, bool use_sendfile,
-                       unsigned long long chunk_size);
-void config_delete(Config *config);
-bool config_send(int file_descriptor, Config *config);
-Config *config_receive(int file_descriptor);
-bool is_remote_dest(const char *s);
-void config_parse_ssh_dest(Config *config);
+Config* config_create(char* version, char* send_directory, char* receive_directory,
+                      bool save_to_disk, bool use_multithreading, bool use_chunk_serialization,
+                      bool use_compression, bool use_metadata, int compression_level,
+                      bool use_sendfile, unsigned long long chunk_size);
+void config_delete(Config* config);
+bool config_send(int file_descriptor, Config* config);
+Config* config_receive(int file_descriptor);
+bool is_remote_dest(const char* s);
+void config_parse_ssh_dest(Config* config);
 
 #endif

src/shared/data.c

@@ -2,8 +2,8 @@
 #include "log.h"
 #include "stdlib.h"
 
-Data *data_create_empty(size_t data_size) {
-  void *data = malloc(data_size);
+Data* data_create_empty(size_t data_size) {
+  void* data = malloc(data_size);
   if (data == NULL) {
     log_message(LOG_LEVEL_ERROR, "Could not allocate memory for empty data");
     return NULL;
@@ -11,8 +11,8 @@ Data *data_create_empty(size_t data_size) {
   return data_create(data, data_size);
 }
 
-Data *data_create_reserve(size_t size) {
-  Data *d = malloc(sizeof(Data));
+Data* data_create_reserve(size_t size) {
+  Data* d = malloc(sizeof(Data));
   if (d == NULL) {
     log_message(LOG_LEVEL_ERROR, "Could not allocate memory for data");
     return NULL;
@@ -22,8 +22,8 @@ Data *data_create_reserve(size_t size) {
   return d;
 }
 
-Data *data_create(void *data, size_t data_size) {
-  Data *new_data = malloc(sizeof(Data));
+Data* data_create(void* data, size_t data_size) {
+  Data* new_data = malloc(sizeof(Data));
   if (new_data == NULL) {
     log_message(LOG_LEVEL_ERROR, "Could not allocate memory for data");
     free(data);
@@ -34,8 +34,9 @@ Data *data_create(void *data, size_t data_size) {
   return new_data;
 }
 
-void data_destroy(Data *data) {
-  if (data == NULL) return;
+void data_destroy(Data* data) {
+  if (data == NULL)
+    return;
   free(data->data);
   free(data);
 }

src/shared/data.h

@@ -4,13 +4,13 @@
 #include "stdlib.h"
 
 typedef struct {
-  void *data;
+  void* data;
   size_t size;
 } Data;
 
-Data *data_create_empty(size_t data_size);
-Data *data_create_reserve(size_t size);
-Data *data_create(void *data, size_t data_size);
-void data_destroy(Data *data);
+Data* data_create_empty(size_t data_size);
+Data* data_create_reserve(size_t size);
+Data* data_create(void* data, size_t data_size);
+void data_destroy(Data* data);
 
 #endif

src/shared/file.c

@@ -19,15 +19,15 @@
 #include "protocol.h"
 #include "utils.h"
 
-File *file_create(const char *path) {
-  File *file = (File *)malloc(sizeof(File));
+File* file_create(const char* path) {
+  File* file = (File*)malloc(sizeof(File));
   if (file == NULL) {
     perror("ERROR: Could not allocate memory for file struct");
     return NULL;
   }
 
   int path_len = strlen(path);
-  file->path = (char *)malloc(path_len + 1);
+  file->path = (char*)malloc(path_len + 1);
   if (file->path == NULL) {
     free(file);
     return NULL;
@@ -44,10 +44,10 @@ File *file_create(const char *path) {
   return file;
 }
 
-void file_destroy(void *item) {
+void file_destroy(void* item) {
   if (item == NULL)
     return;
-  File *file = (File *)item;
+  File* file = (File*)item;
   data_destroy(file->data);
   file->data = NULL;
   file_metadata_destroy(file->metadata);
@@ -57,8 +57,8 @@ void file_destroy(void *item) {
   free(file);
 }
 
-FileMetadata *file_metadata_create(struct stat *stats) {
-  FileMetadata *m = malloc(sizeof(FileMetadata));
+FileMetadata* file_metadata_create(const struct stat* stats) {
+  FileMetadata* m = malloc(sizeof(FileMetadata));
   if (m == NULL) {
     perror("ERROR: Could not allocate memory for file metadata");
     return NULL;
@@ -75,12 +75,13 @@ FileMetadata *file_metadata_create(struct stat *stats) {
   return m;
 }
 
-void file_metadata_destroy(void *metadata) {
+void file_metadata_destroy(void* metadata) {
   free(metadata);
 }
 
-bool file_load_data(File *file) {
-  if (file == NULL) return false;
+bool file_load_data(File* file) {
+  if (file == NULL)
+    return false;
   if (file->data->data == NULL) {
     file->data->data = malloc(file->data->size);
     if (file->data->data == NULL) {
@@ -96,9 +97,10 @@ bool file_load_data(File *file) {
   return true;
 }
 
-bool file_send_single_calls(File *file, int file_descriptor, bool use_metadata, int compression_level, bool send_path) {
-  Data *data_to_send = file->data;
-  Data *compressed_data = NULL;
+bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
+                            int compression_level, bool send_path) {
+  Data* data_to_send = file->data;
+  Data* compressed_data = NULL;
   if (compression_level > 0) {
     compressed_data = data_compress(file->data, compression_level);
     if (compressed_data == NULL) {
@@ -123,18 +125,24 @@ bool file_send_single_calls(File *file, int file_descriptor, bool use_metadata,
   return true;
 }
 
-bool file_save_to_disk(const char *root_directory, File *file) {
-  char *disk_path = path_cat((char *)root_directory, file->path);
-  if (disk_path == NULL) return false;
+bool file_save_to_disk(const char* root_directory, File* file) {
+  char* disk_path = path_cat((char*)root_directory, file->path);
+  if (disk_path == NULL)
+    return false;
   bool ok = to_disk(disk_path, file->data->data, file->data->size);
-  if (ok) file_restore_metadata(disk_path, file->metadata);
+  if (ok)
+    file_restore_metadata(disk_path, file->metadata);
   free(disk_path);
   return ok;
 }
 
-File *receive_incremental_check(int fd, Config *config, bool *skipped) {  *skipped = false;
-  char *check_path = receive_str(fd);
-  if (check_path == NULL) { send_status(fd, STATUS_ERROR); return NULL; }
+File* receive_incremental_check(int fd, Config* config, bool* skipped) {
+  *skipped = false;
+  char* check_path = receive_str(fd);
+  if (check_path == NULL) {
+    send_status(fd, STATUS_ERROR);
+    return NULL;
+  }
 
   unsigned long long check_size;
   long long check_mtime;
@@ -145,36 +153,48 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) {  *skipp
     return NULL;
   }
 
-  char *full_path = path_cat(config->receive_root_directory, check_path);
+  char* full_path = path_cat(config->receive_root_directory, check_path);
   struct stat st;
   bool match = false;
-  if (full_path && stat(full_path, &st) == 0 &&
-      (unsigned long long)st.st_size == check_size &&
+  if (full_path && stat(full_path, &st) == 0 && (unsigned long long)st.st_size == check_size &&
       (long long)st.st_mtime == check_mtime) {
     match = true;
   }
   free(full_path);
 
   if (match) {
-    if (!send_status(fd, STATUS_OK)) { free(check_path); return NULL; }
+    if (!send_status(fd, STATUS_OK)) {
+      free(check_path);
+      return NULL;
+    }
     free(check_path);
     *skipped = true;
     return NULL;
   }
 
-  if (!send_status(fd, STATUS_NEXT)) { free(check_path); return NULL; }
+  if (!send_status(fd, STATUS_NEXT)) {
+    free(check_path);
+    return NULL;
+  }
 
-  File *file = file_create(check_path);
+  File* file = file_create(check_path);
   free(check_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;
     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);
@@ -182,9 +202,13 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) {  *skipp
   }
 
   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;
   }
 
@@ -193,15 +217,15 @@ File *receive_incremental_check(int fd, Config *config, bool *skipped) {  *skipp
   return file;
 }
 
-bool to_disk(const char *path, const void *data, unsigned long long data_size) {
-  char *directory = str_dup(path);
-  char *dir_to_free = directory;
+bool to_disk(const char* path, const void* data, unsigned long long data_size) {
+  char* directory = str_dup(path);
+  char* dir_to_free = directory;
   directory = dirname(directory);
   if (!mkdir_r(directory)) {
     free(dir_to_free);
     return false;
   }
-  FILE *file_pointer = fopen(path, "wb");
+  FILE* file_pointer = fopen(path, "wb");
   if (file_pointer == NULL) {
     perror("Could not open File");
     free(dir_to_free);
@@ -218,9 +242,11 @@ 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, bool send_path) {
-  if (send_path && !send_str(file_descriptor, file->path)) return false;
-  if (use_metadata && !metadata_send(file_descriptor, file->metadata)) return false;
+bool file_send_sendfile(File* file, int file_descriptor, bool use_metadata, bool send_path) {
+  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) {
@@ -248,24 +274,29 @@ bool file_send_sendfile(File *file, int file_descriptor, bool use_metadata, bool
   return true;
 }
 
-File *file_receive(Config *config, int file_descriptor) {
-  char *path = receive_str(file_descriptor);
-  if (path == NULL) return NULL;
-  File *file = file_create(path);
+File* file_receive(const Config* config, int file_descriptor) {
+  char* path = receive_str(file_descriptor);
+  if (path == NULL)
+    return NULL;
+  File* file = file_create(path);
   free(path);
-  if (file == NULL) return NULL;
+  if (file == NULL)
+    return NULL;
   if (config->use_metadata) {
     int meta_ok = 1;
     file->metadata = metadata_receive(file_descriptor, &meta_ok);
-    if (!meta_ok) { file_destroy(file); return NULL; }
+    if (!meta_ok) {
+      file_destroy(file);
+      return NULL;
+    }
   }
-  Data *file_data = receive_data(file_descriptor);
+  Data* file_data = receive_data(file_descriptor);
   if (file_data == NULL) {
     file_destroy(file);
     return NULL;
   }
   if (config->use_compression) {
-    Data *file_data_uncompressed = data_decompress(file_data);
+    Data* file_data_uncompressed = data_decompress(file_data);
     data_destroy(file_data);
     if (file_data_uncompressed == NULL) {
       file_destroy(file);
@@ -278,14 +309,13 @@ File *file_receive(Config *config, int file_descriptor) {
   return file;
 }
 
-size_t file_content_to_buffer(File *file) {
-  FILE *file_pointer = fopen(file->path, "rb");
+size_t file_content_to_buffer(File* file) {
+  FILE* file_pointer = fopen(file->path, "rb");
   if (file_pointer == NULL) {
     perror("Could not open the file!");
     return 0;
   }
-  size_t bytes_read =
-      fread(file->data->data, 1, file->data->size, file_pointer);
+  size_t bytes_read = fread(file->data->data, 1, file->data->size, file_pointer);
   if (bytes_read != (size_t)file->data->size) {
     fclose(file_pointer);
     perror("Read unexpected number of bytes from File!");
@@ -295,21 +325,22 @@ size_t file_content_to_buffer(File *file) {
   return bytes_read;
 }
 
-int receive_manifest(int fd, Config *config, int *next_status) {
+int receive_manifest(int fd, const Config* config, int* next_status) {
   int count;
-  if (!receive_int(fd, &count)) return -1;
-  ArrayList *manifest = array_list_create(free);
+  if (!receive_int(fd, &count))
+    return -1;
+  ArrayList* manifest = array_list_create(free);
   if (manifest) {
     for (int i = 0; i < count; i++) {
-      char *s = receive_str(fd);
-      if (s) array_list_add(manifest, s);
+      char* s = receive_str(fd);
+      if (s)
+        array_list_add(manifest, s);
     }
     fprintf(stderr, "Deleting files not in manifest...\n");
     delete_extras(config->receive_root_directory, manifest);
     array_list_delete(manifest);
   }
-  if (!receive_status(fd, next_status)) return -1;
+  if (!receive_status(fd, next_status))
+    return -1;
   return 0;
 }
-
-

src/shared/file.h

@@ -15,23 +15,24 @@ typedef struct {
 } FileMetadata;
 
 typedef struct {
-  char *path;
-  Data *data;
-  FileMetadata *metadata;
+  char* path;
+  Data* data;
+  FileMetadata* metadata;
 } File;
 
-File *file_create(const char *path);
-void file_destroy(void *item);
-bool file_load_data(File *file);
-File *file_receive(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, bool send_path);
-size_t file_content_to_buffer(File *file);
-FileMetadata *file_metadata_create(struct stat *stats);
-void file_metadata_destroy(void *metadata);
-bool to_disk(const char *path, const void *data, unsigned long long data_size);
-bool file_save_to_disk(const char *root_directory, File *file);
-File *receive_incremental_check(int fd, Config *config, bool *skipped);
-int receive_manifest(int fd, Config *config, int *next_status);
+File* file_create(const char* path);
+void file_destroy(void* item);
+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, 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);
+bool to_disk(const char* path, const void* data, unsigned long long data_size);
+bool file_save_to_disk(const char* root_directory, File* file);
+File* receive_incremental_check(int fd, Config* config, bool* skipped);
+int receive_manifest(int fd, const Config* config, int* next_status);
 
 #endif

src/shared/log.c

@@ -3,22 +3,21 @@
 #include <stdio.h>
 #include <time.h>
 
-static const char *log_level_strings[] = {"DEBUG", "INFO", "WARN", "ERROR"};
+static const char* log_level_strings[] = {"DEBUG", "INFO", "WARN", "ERROR"};
 static LogLevel current_log_level = LOG_LEVEL_WARNING;
 
 void set_log_level(LogLevel level) {
   current_log_level = level;
 }
 
-void log_message(LogLevel log_level, char *format, ...) {
+void log_message(LogLevel log_level, char* format, ...) {
   if (log_level < current_log_level)
     return;
   time_t now = time(NULL);
-  struct tm *t = localtime(&now);
+  const struct tm* t = localtime(&now);
 
-  fprintf(stderr, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900,
-          t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec,
-          log_level_strings[log_level]);
+  fprintf(stderr, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900, t->tm_mon + 1,
+          t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, log_level_strings[log_level]);
 
   va_list args;
   va_start(args, format);

src/shared/log.h

@@ -1,14 +1,9 @@
 #ifndef LOG_H
 #define LOG_H
 
-typedef enum {
-  LOG_LEVEL_DEBUG,
-  LOG_LEVEL_INFO,
-  LOG_LEVEL_WARNING,
-  LOG_LEVEL_ERROR
-} LogLevel;
+typedef enum { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, LOG_LEVEL_ERROR } LogLevel;
 
-void log_message(LogLevel log_level, char *message, ...);
+void log_message(LogLevel log_level, char* message, ...);
 void set_log_level(LogLevel level);
 
 #endif

src/shared/metadata.c

@@ -8,35 +8,45 @@
 #include <time.h>
 #include <unistd.h>
 
-void metadata_to_buf(char **buf, FileMetadata *m) {
+void metadata_to_buf(char** buf, const FileMetadata* m) {
   int present = (m != NULL) ? 1 : 0;
   memcpy(*buf, &present, sizeof(int));
   *buf += sizeof(int);
   if (m == NULL)
     return;
-  memcpy(*buf, &m->mode, sizeof(mode_t));        *buf += sizeof(mode_t);
-  memcpy(*buf, &m->uid, sizeof(uid_t));          *buf += sizeof(uid_t);
-  memcpy(*buf, &m->gid, sizeof(gid_t));          *buf += sizeof(gid_t);
-  memcpy(*buf, &m->mtime_sec, sizeof(time_t));   *buf += sizeof(time_t);
-  memcpy(*buf, &m->mtime_nsec, sizeof(long));    *buf += sizeof(long);
+  memcpy(*buf, &m->mode, sizeof(mode_t));
+  *buf += sizeof(mode_t);
+  memcpy(*buf, &m->uid, sizeof(uid_t));
+  *buf += sizeof(uid_t);
+  memcpy(*buf, &m->gid, sizeof(gid_t));
+  *buf += sizeof(gid_t);
+  memcpy(*buf, &m->mtime_sec, sizeof(time_t));
+  *buf += sizeof(time_t);
+  memcpy(*buf, &m->mtime_nsec, sizeof(long));
+  *buf += sizeof(long);
 }
 
-FileMetadata *metadata_from_buf(char **buf) {
+FileMetadata* metadata_from_buf(char** buf) {
   int present;
   memcpy(&present, *buf, sizeof(int));
   *buf += sizeof(int);
   if (!present)
     return NULL;
-  FileMetadata *m = malloc(sizeof(FileMetadata));
-  memcpy(&m->mode, *buf, sizeof(mode_t));        *buf += sizeof(mode_t);
-  memcpy(&m->uid, *buf, sizeof(uid_t));          *buf += sizeof(uid_t);
-  memcpy(&m->gid, *buf, sizeof(gid_t));          *buf += sizeof(gid_t);
-  memcpy(&m->mtime_sec, *buf, sizeof(time_t));   *buf += sizeof(time_t);
-  memcpy(&m->mtime_nsec, *buf, sizeof(long));    *buf += sizeof(long);
+  FileMetadata* m = malloc(sizeof(FileMetadata));
+  memcpy(&m->mode, *buf, sizeof(mode_t));
+  *buf += sizeof(mode_t);
+  memcpy(&m->uid, *buf, sizeof(uid_t));
+  *buf += sizeof(uid_t);
+  memcpy(&m->gid, *buf, sizeof(gid_t));
+  *buf += sizeof(gid_t);
+  memcpy(&m->mtime_sec, *buf, sizeof(time_t));
+  *buf += sizeof(time_t);
+  memcpy(&m->mtime_nsec, *buf, sizeof(long));
+  *buf += sizeof(long);
   return m;
 }
 
-bool metadata_send(int file_descriptor, FileMetadata *m) {
+bool metadata_send(int file_descriptor, FileMetadata* m) {
   if (m == NULL) {
     int zero = 0;
     return send_n_data(file_descriptor, &zero, sizeof(int));
@@ -50,32 +60,40 @@ bool metadata_send(int file_descriptor, FileMetadata *m) {
          send_n_data(file_descriptor, &m->mtime_nsec, sizeof(long));
 }
 
-FileMetadata *metadata_receive(int file_descriptor, int *ok) {
+FileMetadata* metadata_receive(int file_descriptor, int* ok) {
   int present;
   if (!receive_n_data(file_descriptor, &present, sizeof(int))) {
-    if (ok) *ok = 0;
+    if (ok)
+      *ok = 0;
     return NULL;
   }
   if (!present) {
-    if (ok) *ok = 1;
+    if (ok)
+      *ok = 1;
+    return NULL;
+  }
+  FileMetadata* m = malloc(sizeof(FileMetadata));
+  if (m == NULL) {
+    if (ok)
+      *ok = 0;
     return NULL;
   }
-  FileMetadata *m = malloc(sizeof(FileMetadata));
-  if (m == NULL) { if (ok) *ok = 0; return NULL; }
   if (!receive_n_data(file_descriptor, &m->mode, sizeof(mode_t)) ||
       !receive_n_data(file_descriptor, &m->uid, sizeof(uid_t)) ||
       !receive_n_data(file_descriptor, &m->gid, sizeof(gid_t)) ||
       !receive_n_data(file_descriptor, &m->mtime_sec, sizeof(time_t)) ||
       !receive_n_data(file_descriptor, &m->mtime_nsec, sizeof(long))) {
     free(m);
-    if (ok) *ok = 0;
+    if (ok)
+      *ok = 0;
     return NULL;
   }
-  if (ok) *ok = 1;
+  if (ok)
+    *ok = 1;
   return m;
 }
 
-void file_restore_metadata(const char *path, FileMetadata *metadata) {
+void file_restore_metadata(const char* path, FileMetadata* metadata) {
   if (metadata == NULL)
     return;
   chmod(path, metadata->mode & 07777);

src/shared/metadata.h

@@ -5,12 +5,13 @@
 #include <stdbool.h>
 #include <sys/stat.h>
 
-#define FILE_METADATA_WIRE_SIZE (sizeof(mode_t) + sizeof(uid_t) + sizeof(gid_t) + sizeof(time_t) + sizeof(long))
+#define FILE_METADATA_WIRE_SIZE                                                                    \
+  (sizeof(mode_t) + sizeof(uid_t) + sizeof(gid_t) + sizeof(time_t) + sizeof(long))
 
-void metadata_to_buf(char **buf, FileMetadata *m);
-FileMetadata *metadata_from_buf(char **buf);
-bool metadata_send(int file_descriptor, FileMetadata *m);
-FileMetadata *metadata_receive(int file_descriptor, int *ok);
-void file_restore_metadata(const char *path, FileMetadata *metadata);
+void metadata_to_buf(char** buf, const FileMetadata* m);
+FileMetadata* metadata_from_buf(char** buf);
+bool metadata_send(int file_descriptor, FileMetadata* m);
+FileMetadata* metadata_receive(int file_descriptor, int* ok);
+void file_restore_metadata(const char* path, FileMetadata* metadata);
 
 #endif

src/shared/multiprocessing.c

@@ -13,11 +13,11 @@
 #include <string.h>
 #include <threads.h>
 
-PipelineContextSender *pipeline_context_sender_create(Config *config,
-                                                      Queue *queue_scanner,
-                                                      Queue *queue_loader) {
-  PipelineContextSender *context = malloc(sizeof(PipelineContextSender));
-  if (context == NULL) return NULL;
+PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* queue_scanner,
+                                                      Queue* queue_loader) {
+  PipelineContextSender* context = malloc(sizeof(PipelineContextSender));
+  if (context == NULL)
+    return NULL;
   context->config = config;
   context->queue_scanner = queue_scanner;
   context->queue_loader = queue_loader;
@@ -37,7 +37,7 @@ PipelineContextSender *pipeline_context_sender_create(Config *config,
   return context;
 }
 
-void pipeline_context_sender_destroy(PipelineContextSender *context) {
+void pipeline_context_sender_destroy(PipelineContextSender* context) {
   if (context->manifest) {
     array_list_delete(context->manifest);
   }
@@ -53,11 +53,11 @@ void pipeline_context_sender_destroy(PipelineContextSender *context) {
   free(context);
 }
 
-PipelineContextReceiver *pipeline_context_receiver_create(Config *config,
-                                                          Queue *queue,
+PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue* queue,
                                                           int file_descriptor) {
-  PipelineContextReceiver *context = malloc(sizeof(PipelineContextReceiver));
-  if (context == NULL) return NULL;
+  PipelineContextReceiver* context = malloc(sizeof(PipelineContextReceiver));
+  if (context == NULL)
+    return NULL;
   context->config = config;
   context->queue = queue;
   context->file_descriptor = file_descriptor;
@@ -72,7 +72,7 @@ PipelineContextReceiver *pipeline_context_receiver_create(Config *config,
   return context;
 }
 
-void pipeline_context_receiver_destroy(PipelineContextReceiver *context) {
+void pipeline_context_receiver_destroy(PipelineContextReceiver* context) {
   config_delete(context->config);
   queue_destroy(context->queue);
   mtx_destroy(&context->mutex);
@@ -81,57 +81,57 @@ void pipeline_context_receiver_destroy(PipelineContextReceiver *context) {
   free(context);
 }
 
-static void receive_chunk_enqueue(int file_descriptor,
-                                  PipelineContextReceiver *context) {
-  Chunk *chunk = receive_chunk_data(file_descriptor, context->config);
-  if (chunk == NULL) return;
+static void receive_chunk_enqueue(int file_descriptor, PipelineContextReceiver* context) {
+  Chunk* chunk = receive_chunk_data(file_descriptor, context->config);
+  if (chunk == NULL)
+    return;
 
   for (int i = 0; i < chunk->element_count; i++) {
-    File *file = chunk->items[i];
+    File* file = chunk->items[i];
     chunk->items[i] = NULL;
     queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                &context->condition_not_empty,
-                                &context->condition_not_full);
+                                &context->condition_not_empty, &context->condition_not_full);
   }
   chunk_destroy(chunk);
 }
 
-int receive_thread(void *pipeline_context) {
-  PipelineContextReceiver *context =
-      (PipelineContextReceiver *)pipeline_context;
+int receive_thread(void* pipeline_context) {
+  PipelineContextReceiver* context = (PipelineContextReceiver*)pipeline_context;
   mtx_lock(&context->mutex);
   int file_descriptor = context->file_descriptor;
-  Config *config = context->config;
+  Config* config = context->config;
   mtx_unlock(&context->mutex);
 
   Status status;
-  if (!receive_status(file_descriptor, &status)) return thrd_error;
+  if (!receive_status(file_descriptor, &status))
+    return thrd_error;
   while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK) {
     if (status == STATUS_CHECK) {
       bool skipped;
-      File *file = receive_incremental_check(file_descriptor, config, &skipped);
+      File* file = receive_incremental_check(file_descriptor, config, &skipped);
       if (!skipped) {
-        if (file == NULL) return thrd_error;
+        if (file == NULL)
+          return thrd_error;
         queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                    &context->condition_not_empty,
-                                    &context->condition_not_full);
+                                    &context->condition_not_empty, &context->condition_not_full);
       }
     } else if (status == STATUS_CHUNK) {
       receive_chunk_enqueue(file_descriptor, context);
     } else {
-      File *file = file_receive(config, file_descriptor);
+      File* file = file_receive(config, file_descriptor);
       if (file) {
         queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                    &context->condition_not_empty,
-                                    &context->condition_not_full);
+                                    &context->condition_not_empty, &context->condition_not_full);
       } else {
         log_message(LOG_LEVEL_ERROR, "Failed to receive file");
       }
     }
-    if (!receive_status(file_descriptor, &status)) return thrd_error;
+    if (!receive_status(file_descriptor, &status))
+      return thrd_error;
   }
   if (status == STATUS_MANIFEST) {
-    if (receive_manifest(file_descriptor, config, &status) != 0) return thrd_error;
+    if (receive_manifest(file_descriptor, config, &status) != 0)
+      return thrd_error;
   }
   mtx_lock(&context->mutex);
   context->receiver_done = true;
@@ -140,18 +140,17 @@ int receive_thread(void *pipeline_context) {
   return thrd_success;
 }
 
-int write_thread(void *pipeline_context) {
-  PipelineContextReceiver *context =
-      (PipelineContextReceiver *)pipeline_context;
+int write_thread(void* pipeline_context) {
+  PipelineContextReceiver* context = (PipelineContextReceiver*)pipeline_context;
   mtx_lock(&context->mutex);
   bool save_to_disk = context->config->save_to_disk;
-  char *root_directory = str_dup(context->config->receive_root_directory);
+  char* root_directory = str_dup(context->config->receive_root_directory);
   mtx_unlock(&context->mutex);
 
   while (true) {
-    File *file = queue_dequeue_multithreaded(
-        context->queue, &context->mutex, &context->condition_not_empty,
-        &context->condition_not_full, &context->receiver_done);
+    File* file =
+        queue_dequeue_multithreaded(context->queue, &context->mutex, &context->condition_not_empty,
+                                    &context->condition_not_full, &context->receiver_done);
     if (file == NULL) {
       free(root_directory);
       return thrd_success;

src/shared/multiprocessing.h

@@ -9,23 +9,23 @@
 #include "queue.h"
 
 typedef struct {
-  Config *config;
-  Queue *queue_scanner;
+  Config* config;
+  Queue* queue_scanner;
   mtx_t mutex_scanner;
   cnd_t condition_not_full_scanner;
   cnd_t condition_not_empty_scanner;
   bool scanner_done;
-  Queue *queue_loader;
+  Queue* queue_loader;
   mtx_t mutex_loader;
   cnd_t condition_not_full_loader;
   cnd_t condition_not_empty_loader;
   bool loader_done;
-  ArrayList *manifest;
+  ArrayList* manifest;
 } PipelineContextSender;
 
 typedef struct PipelineContextReceiver {
-  Queue *queue;
-  Config *config;
+  Queue* queue;
+  Config* config;
   int file_descriptor;
   mtx_t mutex;
   cnd_t condition_not_full;
@@ -33,14 +33,12 @@ typedef struct PipelineContextReceiver {
   bool receiver_done;
 } PipelineContextReceiver;
 
-PipelineContextSender *pipeline_context_sender_create(Config *config,
-                                                      Queue *queue_scanner,
-                                                      Queue *queue_loader);
-void pipeline_context_sender_destroy(PipelineContextSender *context);
-PipelineContextReceiver *pipeline_context_receiver_create(Config *config,
-                                                          Queue *queue_receiver,
+PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* queue_scanner,
+                                                      Queue* queue_loader);
+void pipeline_context_sender_destroy(PipelineContextSender* context);
+PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue* queue_receiver,
                                                           int file_descriptor);
-void pipeline_context_receiver_destroy(PipelineContextReceiver *context);
-int receive_thread(void *pipeline_context);
-int write_thread(void *pipeline_context);
+void pipeline_context_receiver_destroy(PipelineContextReceiver* context);
+int receive_thread(void* pipeline_context);
+int write_thread(void* pipeline_context);
 #endif

src/shared/protocol.c

@@ -10,7 +10,7 @@
 
 static __thread int io_read_fd = -1;
 static __thread int io_write_fd = -1;
-static SSL *io_ssl = NULL;
+static SSL* io_ssl = NULL;
 
 static unsigned long long io_bwlimit = 0;
 static long long bw_tokens = 0;
@@ -28,13 +28,14 @@ void io_set_bwlimit(unsigned long long bytes_per_sec) {
 }
 
 static void bw_throttle(size_t bytes_written) {
-  if (io_bwlimit == 0) return;
+  if (io_bwlimit == 0)
+    return;
 
   struct timespec now;
   clock_gettime(CLOCK_MONOTONIC, &now);
 
-  long long elapsed_ns = (now.tv_sec - bw_last_refill.tv_sec) * 1000000000LL +
-                         (now.tv_nsec - bw_last_refill.tv_nsec);
+  long long elapsed_ns =
+      (now.tv_sec - bw_last_refill.tv_sec) * 1000000000LL + (now.tv_nsec - bw_last_refill.tv_nsec);
   bw_last_refill = now;
 
   long long tokens_to_add = (long long)((double)io_bwlimit * elapsed_ns / 1000000000.0);
@@ -56,7 +57,7 @@ static void bw_throttle(size_t bytes_written) {
   }
 }
 
-void io_set_ssl(SSL *ssl) {
+void io_set_ssl(SSL* ssl) {
   io_ssl = ssl;
 }
 
@@ -64,7 +65,7 @@ static int io_fd(int dir_fd, int file_descriptor) {
   return (dir_fd != -1) ? dir_fd : file_descriptor;
 }
 
-bool send_n_data(int file_descriptor, void *data, size_t data_size) {
+bool send_n_data(int file_descriptor, void* data, size_t data_size) {
   log_message(LOG_LEVEL_DEBUG, "    Sending n Data: %zu", data_size);
   int fd = io_fd(io_write_fd, file_descriptor);
   ssize_t total_bytes_send = 0;
@@ -74,9 +75,9 @@ bool send_n_data(int file_descriptor, void *data, size_t data_size) {
       chunk = 65536;
     ssize_t bytes_send;
     if (io_ssl)
-      bytes_send = SSL_write(io_ssl, (char *)data + total_bytes_send, chunk);
+      bytes_send = SSL_write(io_ssl, (char*)data + total_bytes_send, chunk);
     else
-      bytes_send = write(fd, (char *)data + total_bytes_send, chunk);
+      bytes_send = write(fd, (char*)data + total_bytes_send, chunk);
     if (bytes_send <= 0) {
       log_message(LOG_LEVEL_ERROR, "Could not send data");
       return false;
@@ -88,18 +89,18 @@ bool send_n_data(int file_descriptor, void *data, size_t data_size) {
   return true;
 }
 
-bool receive_n_data(int file_descriptor, void *data, size_t data_size) {
+bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
   log_message(LOG_LEVEL_DEBUG, "    Receiving n Data: %zu", data_size);
   int fd = io_fd(io_read_fd, file_descriptor);
   size_t total_bytes_received = 0;
   while (total_bytes_received < data_size) {
     ssize_t bytes_received;
     if (io_ssl)
-      bytes_received = SSL_read(io_ssl, (char *)data + total_bytes_received,
-                                data_size - total_bytes_received);
+      bytes_received =
+          SSL_read(io_ssl, (char*)data + total_bytes_received, data_size - total_bytes_received);
     else
-      bytes_received = read(fd, (char *)data + total_bytes_received,
-                             data_size - total_bytes_received);
+      bytes_received =
+          read(fd, (char*)data + total_bytes_received, data_size - total_bytes_received);
     if (bytes_received <= 0) {
       if (bytes_received == 0)
         log_message(LOG_LEVEL_ERROR, "Connection closed while receiving data");
@@ -113,7 +114,7 @@ bool receive_n_data(int file_descriptor, void *data, size_t data_size) {
   return true;
 }
 
-static const char *status_to_string(Status status) {
+static const char* status_to_string(Status status) {
   switch (status) {
   case STATUS_OK:
     return "OK";
@@ -132,19 +133,23 @@ static const char *status_to_string(Status status) {
   }
 }
 
-bool send_str(int file_descriptor, char *data) {
+bool send_str(int file_descriptor, char* data) {
   size_t size = strlen(data);
-  if (!send_n_data(file_descriptor, &size, sizeof(size_t))) return false;
-  if (!send_n_data(file_descriptor, data, size)) return false;
+  if (!send_n_data(file_descriptor, &size, sizeof(size_t)))
+    return false;
+  if (!send_n_data(file_descriptor, data, size))
+    return false;
   log_message(LOG_LEVEL_DEBUG, "Send String: %s", data);
   return true;
 }
 
-char *receive_str(int file_descriptor) {
+char* receive_str(int file_descriptor) {
   size_t size;
-  if (!receive_n_data(file_descriptor, &size, sizeof(size_t))) return NULL;
-  char *data = (char *)malloc(size + 1);
-  if (data == NULL) return NULL;
+  if (!receive_n_data(file_descriptor, &size, sizeof(size_t)))
+    return NULL;
+  char* data = (char*)malloc(size + 1);
+  if (data == NULL)
+    return NULL;
   if (!receive_n_data(file_descriptor, data, size)) {
     free(data);
     return NULL;
@@ -154,7 +159,7 @@ char *receive_str(int file_descriptor) {
   return data;
 }
 
-bool send_data(int file_descriptor, Data *data) {
+bool send_data(int file_descriptor, Data* data) {
   unsigned long long data_size = data->size;
   if (!send_n_data(file_descriptor, &data_size, sizeof(unsigned long long)))
     return false;
@@ -164,12 +169,13 @@ bool send_data(int file_descriptor, Data *data) {
   return true;
 }
 
-Data *receive_data(int file_descriptor) {
+Data* receive_data(int file_descriptor) {
   unsigned long long size = 0;
   if (!receive_n_data(file_descriptor, &size, sizeof(unsigned long long)))
     return NULL;
-  void *data = malloc((size_t)size);
-  if (data == NULL) return NULL;
+  void* data = malloc((size_t)size);
+  if (data == NULL)
+    return NULL;
   if (!receive_n_data(file_descriptor, data, (size_t)size)) {
     free(data);
     return NULL;
@@ -179,25 +185,29 @@ Data *receive_data(int file_descriptor) {
 }
 
 bool send_int(int file_descriptor, int data) {
-  if (!send_n_data(file_descriptor, &data, sizeof(int))) return false;
+  if (!send_n_data(file_descriptor, &data, sizeof(int)))
+    return false;
   log_message(LOG_LEVEL_DEBUG, "Send Int: %d", data);
   return true;
 }
 
-bool receive_int(int file_descriptor, int *data) {
-  if (!receive_n_data(file_descriptor, data, sizeof(int))) return false;
+bool receive_int(int file_descriptor, int* data) {
+  if (!receive_n_data(file_descriptor, data, sizeof(int)))
+    return false;
   log_message(LOG_LEVEL_DEBUG, "Received Int: %d", *data);
   return true;
 }
 
 bool send_status(int file_descriptor, Status status) {
-  if (!send_n_data(file_descriptor, &status, sizeof(Status))) return false;
+  if (!send_n_data(file_descriptor, &status, sizeof(Status)))
+    return false;
   log_message(LOG_LEVEL_DEBUG, "Send Status: %s", status_to_string(status));
   return true;
 }
 
-bool receive_status(int file_descriptor, Status *status) {
-  if (!receive_n_data(file_descriptor, status, sizeof(Status))) return false;
+bool receive_status(int file_descriptor, Status* status) {
+  if (!receive_n_data(file_descriptor, status, sizeof(Status)))
+    return false;
   log_message(LOG_LEVEL_DEBUG, "Received Status: %s", status_to_string(*status));
   return true;
 }

src/shared/protocol.h

@@ -8,22 +8,30 @@
 typedef struct ssl_st SSL;
 
 typedef int Status;
-enum NET_STATUS { STATUS_OK, STATUS_ERROR, STATUS_FINISHED, STATUS_NEXT, STATUS_CHUNK, STATUS_MANIFEST, STATUS_CHECK };
+enum NET_STATUS {
+  STATUS_OK,
+  STATUS_ERROR,
+  STATUS_FINISHED,
+  STATUS_NEXT,
+  STATUS_CHUNK,
+  STATUS_MANIFEST,
+  STATUS_CHECK
+};
 
 void io_set_fds(int read_fd, int write_fd);
 void io_set_bwlimit(unsigned long long bytes_per_sec);
 typedef struct ssl_st SSL;
-void io_set_ssl(SSL *ssl);
-bool send_n_data(int file_descriptor, void *data, size_t data_size);
-bool receive_n_data(int file_descriptor, void *data, size_t data_size);
+void io_set_ssl(SSL* ssl);
+bool send_n_data(int file_descriptor, void* data, size_t data_size);
+bool receive_n_data(int file_descriptor, void* data, size_t data_size);
 
-bool send_str(int file_descriptor, char *data);
-char *receive_str(int file_descriptor);
-bool send_data(int file_descriptor, Data *data);
-Data *receive_data(int file_descriptor);
+bool send_str(int file_descriptor, char* data);
+char* receive_str(int file_descriptor);
+bool send_data(int file_descriptor, Data* data);
+Data* receive_data(int file_descriptor);
 bool send_int(int file_descriptor, int data);
-bool receive_int(int file_descriptor, int *data);
+bool receive_int(int file_descriptor, int* data);
 bool send_status(int file_descriptor, Status status);
-bool receive_status(int file_descriptor, Status *status);
+bool receive_status(int file_descriptor, Status* status);
 
 #endif

src/shared/queue.c

@@ -6,14 +6,14 @@
 
 #include "queue.h"
 
-Queue *queue_create(int capacity, void (*destroyer)(void *item)) {
-  Queue *queue = (Queue *)malloc(sizeof(Queue));
+Queue* queue_create(int capacity, void (*destroyer)(void* item)) {
+  Queue* queue = (Queue*)malloc(sizeof(Queue));
   if (queue == NULL) {
     perror("ERROR: Could not allocate memory for queue structure");
     return NULL;
   }
 
-  queue->items = malloc(capacity * sizeof(void *));
+  queue->items = malloc(capacity * sizeof(void*));
   if (queue->items == NULL) {
     free(queue);
     return NULL;
@@ -32,7 +32,7 @@ Queue *queue_create(int capacity, void (*destroyer)(void *item)) {
   return queue;
 }
 
-void queue_destroy(Queue *queue) {
+void queue_destroy(Queue* queue) {
   if (queue == NULL)
     return;
 
@@ -46,24 +46,25 @@ void queue_destroy(Queue *queue) {
   free(queue);
 }
 
-bool queue_is_empty(Queue *queue) {
+bool queue_is_empty(const Queue* queue) {
   if (queue == NULL)
     return true;
   return queue->size == 0;
 }
 
-bool queue_is_full(Queue *queue) {
+bool queue_is_full(const Queue* queue) {
   if (queue == NULL)
     return false;
   return queue->size == queue->capacity;
 }
 
-static bool queue_double_capacity(Queue *queue) {
-  if (queue == NULL) return false;
+static bool queue_double_capacity(Queue* queue) {
+  if (queue == NULL)
+    return false;
   unsigned int new_capacity = queue->capacity * 2;
   if (new_capacity <= 1)
     new_capacity = 100;
-  void **new_items = malloc(new_capacity * sizeof(void *));
+  void** new_items = malloc(new_capacity * sizeof(void*));
   if (new_items == NULL) {
     perror("ERROR: Could not allocate memory for doubling capacity of queue.");
     return false;
@@ -78,10 +79,12 @@ static bool queue_double_capacity(Queue *queue) {
   return true;
 }
 
-bool queue_enqueue(Queue *queue, void *item) {
-  if (queue == NULL || item == NULL) return false;
+bool queue_enqueue(Queue* queue, void* item) {
+  if (queue == NULL || item == NULL)
+    return false;
   if (queue_is_full(queue)) {
-    if (!queue_double_capacity(queue)) return false;
+    if (!queue_double_capacity(queue))
+      return false;
   }
   queue->items[queue->rear] = item;
   queue->rear = (queue->rear + 1) % queue->capacity;
@@ -89,9 +92,8 @@ bool queue_enqueue(Queue *queue, void *item) {
   return true;
 }
 
-bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex,
-                                 cnd_t *condition_not_empty,
-                                 cnd_t *condition_not_full) {
+bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t* condition_not_empty,
+                                 cnd_t* condition_not_full) {
   mtx_lock(mutex);
   while (queue_is_full(queue))
     cnd_wait(condition_not_full, mutex);
@@ -101,23 +103,21 @@ bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex,
   return ok;
 }
 
-void *queue_dequeue(Queue *queue) {
+void* queue_dequeue(Queue* queue) {
   if (queue == NULL || queue_is_empty(queue)) {
     perror("ERROR: Could not dequeue from null or empty queue.");
     return NULL;
   }
 
-  void *item = queue->items[queue->front];
+  void* item = queue->items[queue->front];
   queue->items[queue->front] = NULL;
   queue->front = (queue->front + 1) % queue->capacity;
   queue->size--;
   return item;
 }
 
-void *queue_dequeue_multithreaded(Queue *queue, mtx_t *mutex,
-                                  cnd_t *condition_not_empty,
-                                  cnd_t *condition_not_full,
-                                  bool *other_thread_done) {
+void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty,
+                                   cnd_t* condition_not_full, const bool* other_thread_done) {
   mtx_lock(mutex);
   while (queue_is_empty(queue) && !*other_thread_done)
     cnd_wait(condition_not_empty, mutex);
@@ -125,7 +125,7 @@ void *queue_dequeue_multithreaded(Queue *queue, mtx_t *mutex,
     mtx_unlock(mutex);
     return NULL;
   }
-  void *item = queue_dequeue(queue);
+  void* item = queue_dequeue(queue);
   cnd_signal(condition_not_full);
   mtx_unlock(mutex);
   return item;

src/shared/queue.h

@@ -5,26 +5,23 @@
 #include <threads.h>
 
 typedef struct Queue {
-  void **items;
+  void** items;
   int front;
   int rear;
   int size;
   int capacity;
-  void (*item_destroyer)(void *item);
+  void (*item_destroyer)(void* item);
 } Queue;
 
-Queue *queue_create(int capacity, void (*destroyer)(void *item));
-void queue_destroy(Queue *queue);
-bool queue_is_empty(Queue *queue);
-bool queue_is_full(Queue *queue);
-bool queue_enqueue(Queue *queue, void *item);
-bool queue_enqueue_multithreaded(Queue *queue, void *item, mtx_t *mutex,
-                                 cnd_t *condition_not_empty,
-                                 cnd_t *condition_not_full);
-void *queue_dequeue(Queue *queue);
-void *queue_dequeue_multithreaded(Queue *queue, mtx_t *mutex,
-                                  cnd_t *condition_not_empty,
-                                  cnd_t *condition_not_full,
-                                  bool *other_thread_done);
+Queue* queue_create(int capacity, void (*destroyer)(void* item));
+void queue_destroy(Queue* queue);
+bool queue_is_empty(const Queue* queue);
+bool queue_is_full(const Queue* queue);
+bool queue_enqueue(Queue* queue, void* item);
+bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t* condition_not_empty,
+                                 cnd_t* condition_not_full);
+void* queue_dequeue(Queue* queue);
+void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty,
+                                   cnd_t* condition_not_full, const bool* other_thread_done);
 
 #endif

src/shared/transport_ssh.c

@@ -13,36 +13,41 @@ typedef struct {
   char remote_path[4096];
 } RemoteDest;
 
-static int parse_remote_dest(const char *dest, RemoteDest *r) {
-  const char *colon = strchr(dest, ':');
-  if (!colon) return -1;
+static int parse_remote_dest(const char* dest, RemoteDest* r) {
+  const char* colon = strchr(dest, ':');
+  if (!colon)
+    return -1;
 
   size_t remote_path_len = strlen(colon + 1);
-  if (remote_path_len >= sizeof(r->remote_path)) return -1;
+  if (remote_path_len >= sizeof(r->remote_path))
+    return -1;
   memcpy(r->remote_path, colon + 1, remote_path_len + 1);
 
-  const char *at = memchr(dest, '@', colon - dest);
+  const char* at = memchr(dest, '@', colon - dest);
   if (at) {
     size_t user_len = at - dest;
-    if (user_len >= sizeof(r->user)) return -1;
+    if (user_len >= sizeof(r->user))
+      return -1;
     memcpy(r->user, dest, user_len);
     r->user[user_len] = '\0';
 
     size_t host_len = colon - at - 1;
-    if (host_len >= sizeof(r->host)) return -1;
+    if (host_len >= sizeof(r->host))
+      return -1;
     memcpy(r->host, at + 1, host_len);
     r->host[host_len] = '\0';
   } else {
     r->user[0] = '\0';
     size_t host_len = colon - dest;
-    if (host_len >= sizeof(r->host)) return -1;
+    if (host_len >= sizeof(r->host))
+      return -1;
     memcpy(r->host, dest, host_len);
     r->host[host_len] = '\0';
   }
   return 0;
 }
 
-Client *client_connect_ssh(char *destination, int port) {
+Client* client_connect_ssh(const char* destination, int port) {
   RemoteDest r;
   if (parse_remote_dest(destination, &r) != 0) {
     fprintf(stderr, "Invalid remote destination: %s\n", destination);
@@ -64,15 +69,18 @@ Client *client_connect_ssh(char *destination, int port) {
   int exec_pipe[2];
   if (pipe(exec_pipe) < 0) {
     perror("pipe failed");
-    close(sv[0]); close(sv[1]);
+    close(sv[0]);
+    close(sv[1]);
     return NULL;
   }
 
   pid_t pid = fork();
   if (pid < 0) {
     perror("fork failed");
-    close(sv[0]); close(sv[1]);
-    close(exec_pipe[0]); close(exec_pipe[1]);
+    close(sv[0]);
+    close(sv[1]);
+    close(exec_pipe[0]);
+    close(exec_pipe[1]);
     return NULL;
   }
 
@@ -85,7 +93,8 @@ Client *client_connect_ssh(char *destination, int port) {
       dup2(sv[1], STDIN_FILENO);
     if (sv[1] != STDOUT_FILENO)
       dup2(sv[1], STDOUT_FILENO);
-    if (sv[1] > 1) close(sv[1]);
+    if (sv[1] > 1)
+      close(sv[1]);
 
     char ssh_user[512];
     if (r.user[0] != '\0')
@@ -93,7 +102,7 @@ Client *client_connect_ssh(char *destination, int port) {
     else
       snprintf(ssh_user, sizeof(ssh_user), "%s", r.host);
 
-    char *ssh_argv[16];
+    char* ssh_argv[16];
     int ac = 0;
     char port_str[16];
     ssh_argv[ac++] = "ssh";
@@ -133,7 +142,7 @@ Client *client_connect_ssh(char *destination, int port) {
     return NULL;
   }
 
-  Client *client = malloc(sizeof(Client));
+  Client* client = malloc(sizeof(Client));
   if (client == NULL) {
     close(sv[0]);
     waitpid(pid, NULL, 0);

src/shared/transport_ssh.h

@@ -3,6 +3,6 @@
 
 #include "transport_tcp.h"
 
-Client *client_connect_ssh(char *destination, int port);
+Client* client_connect_ssh(const char* destination, int port);
 
 #endif

src/shared/transport_tcp.c

@@ -11,8 +11,8 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
-Server *server_create(int port) {
-  Server *server = (Server *)malloc(sizeof(Server));
+Server* server_create(int port) {
+  Server* server = (Server*)malloc(sizeof(Server));
   if (server == NULL) {
     perror("Could not allocate space for Server");
     return NULL;
@@ -26,8 +26,7 @@ Server *server_create(int port) {
   }
   server->file_descriptor = file_descriptor;
   int opt = 1;
-  if (setsockopt(server->file_descriptor, SOL_SOCKET, SO_REUSEADDR, &opt,
-                 sizeof(opt))) {
+  if (setsockopt(server->file_descriptor, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
     perror("Error setting a socket option!");
     close(server->file_descriptor);
     free(server);
@@ -40,8 +39,8 @@ Server *server_create(int port) {
   server->address_length = sizeof(server->address);
   server->ssl_ctx = NULL;
 
-  if (bind(server->file_descriptor, (struct sockaddr *)&server->address,
-           server->address_length) < 0) {
+  if (bind(server->file_descriptor, (struct sockaddr*)&server->address, server->address_length) <
+      0) {
     perror("Could not bind server");
     close(server->file_descriptor);
     free(server);
@@ -51,8 +50,9 @@ Server *server_create(int port) {
   return server;
 }
 
-void server_delete(Server **server) {
-  if (server == NULL || *server == NULL) return;
+void server_delete(Server** server) {
+  if (server == NULL || *server == NULL)
+    return;
   close((*server)->file_descriptor);
   if ((*server)->ssl_ctx) {
     SSL_CTX_free((*server)->ssl_ctx);
@@ -62,8 +62,8 @@ void server_delete(Server **server) {
   *server = NULL;
 }
 
-static void accept_loop(Server *server, void (*child_fn)(int, void *),
-                        void *child_ctx, const char *log_fmt) {
+static void accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
+                        const char* log_fmt) {
   if (listen(server->file_descriptor, SOMAXCONN) < 0) {
     perror("Could not listen on port!");
     return;
@@ -72,8 +72,7 @@ static void accept_loop(Server *server, void (*child_fn)(int, void *),
   while (1) {
     struct sockaddr_in client_addr;
     socklen_t client_len = sizeof(client_addr);
-    int fd = accept(server->file_descriptor, (struct sockaddr *)&client_addr,
-                    &client_len);
+    int fd = accept(server->file_descriptor, (struct sockaddr*)&client_addr, &client_len);
     if (fd < 0) {
       perror("Could not accept the connection");
       continue;
@@ -90,35 +89,35 @@ static void accept_loop(Server *server, void (*child_fn)(int, void *),
   }
 }
 
-struct plain_ctx { void (*handler)(int); };
+struct plain_ctx {
+  void (*handler)(int);
+};
 
-static void plain_child_fn(int fd, void *ctx) {
-  ((struct plain_ctx *)ctx)->handler(fd);
+static void plain_child_fn(int fd, void* ctx) {
+  ((struct plain_ctx*)ctx)->handler(fd);
 }
 
-bool server_listen(Server *server, void (*handler)(int file_descriptor)) {
-  log_message(LOG_LEVEL_INFO, "Start Listening on Port: %d",
-              ntohs(server->address.sin_port));
+bool server_listen(Server* server, void (*handler)(int file_descriptor)) {
+  log_message(LOG_LEVEL_INFO, "Start Listening on Port: %d", ntohs(server->address.sin_port));
   struct plain_ctx ctx = {handler};
   accept_loop(server, plain_child_fn, &ctx, "Received Connection");
   return true;
 }
 
-void server_accept_loop(Server *server, void (*child_fn)(int, void *),
-                        void *child_ctx, const char *log_fmt) {
-  log_message(LOG_LEVEL_INFO, "Start TLS Listening on Port: %d",
-              ntohs(server->address.sin_port));
+void server_accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
+                        const char* log_fmt) {
+  log_message(LOG_LEVEL_INFO, "Start TLS Listening on Port: %d", ntohs(server->address.sin_port));
   accept_loop(server, child_fn, child_ctx, log_fmt);
 }
 
-Client *client_create() {
+Client* client_create() {
   int file_descriptor = socket(AF_INET, SOCK_STREAM, 0);
   if (file_descriptor < 0) {
     perror("Could not create Socket!");
     return NULL;
   }
 
-  Client *client = (Client *)malloc(sizeof(Client));
+  Client* client = (Client*)malloc(sizeof(Client));
   if (client == NULL) {
     close(file_descriptor);
     return NULL;
@@ -132,7 +131,7 @@ Client *client_create() {
   return client;
 }
 
-bool client_connect(Client *client, char *host, int port) {
+bool client_connect(Client* client, char* host, int port) {
   client->address.sin_port = htons(port);
 
   if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) {
@@ -140,15 +139,15 @@ bool client_connect(Client *client, char *host, int port) {
     return false;
   }
 
-  if (connect(client->file_descriptor, (struct sockaddr *)&client->address,
-              client->address_length) < 0) {
+  if (connect(client->file_descriptor, (struct sockaddr*)&client->address, client->address_length) <
+      0) {
     perror("Could not connect to Server!");
     return false;
   }
   return true;
 }
 
-void client_disconnect(Client *client) {
+void client_disconnect(Client* client) {
   if (client->ssl) {
     SSL_shutdown(client->ssl);
     SSL_free(client->ssl);
@@ -163,8 +162,9 @@ void client_disconnect(Client *client) {
   }
 }
 
-void client_delete(Client *client) {
-  if (client == NULL) return;
+void client_delete(Client* client) {
+  if (client == NULL)
+    return;
   if (client->ssl_ctx) {
     SSL_CTX_free(client->ssl_ctx);
     client->ssl_ctx = NULL;

src/shared/transport_tcp.h

@@ -9,7 +9,7 @@ typedef struct Server {
   struct sockaddr_in address;
   unsigned int address_length;
   int file_descriptor;
-  void *ssl_ctx;
+  void* ssl_ctx;
 } Server;
 
 typedef struct Client {
@@ -17,18 +17,18 @@ typedef struct Client {
   unsigned int address_length;
   int file_descriptor;
   pid_t ssh_child_pid;
-  void *ssl;
-  void *ssl_ctx;
+  void* ssl;
+  void* ssl_ctx;
 } Client;
 
-Server *server_create(int port);
-bool server_listen(Server *server, void (*handler)(int file_descriptor));
-void server_accept_loop(Server *server, void (*child_fn)(int, void *),
-                        void *child_ctx, const char *log_fmt);
-void server_delete(Server **server);
-Client *client_create();
-bool client_connect(Client *client, char *host, int port);
-void client_disconnect(Client *client);
-void client_delete(Client *client);
+Server* server_create(int port);
+bool server_listen(Server* server, void (*handler)(int file_descriptor));
+void server_accept_loop(Server* server, void (*child_fn)(int, void*), void* child_ctx,
+                        const char* log_fmt);
+void server_delete(Server** server);
+Client* client_create();
+bool client_connect(Client* client, char* host, int port);
+void client_disconnect(Client* client);
+void client_delete(Client* client);
 
 #endif

src/shared/transport_tls.c

@@ -31,11 +31,10 @@ static void log_ssl_errors(void) {
   }
 }
 
-static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert,
-                                const char *key, const char *ca_path) {
-  const SSL_METHOD *method =
-      is_server ? TLS_server_method() : TLS_client_method();
-  SSL_CTX *ctx = SSL_CTX_new(method);
+static SSL_CTX* create_ssl_ctx(bool is_server, const char* cert, const char* key,
+                               const char* ca_path) {
+  const SSL_METHOD* method = is_server ? TLS_server_method() : TLS_client_method();
+  SSL_CTX* ctx = SSL_CTX_new(method);
   if (!ctx) {
     log_message(LOG_LEVEL_ERROR, "Unable to create SSL context");
     log_ssl_errors();
@@ -58,8 +57,7 @@ static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert,
       return NULL;
     }
     if (!SSL_CTX_check_private_key(ctx)) {
-      log_message(LOG_LEVEL_ERROR,
-                  "Private key does not match certificate");
+      log_message(LOG_LEVEL_ERROR, "Private key does not match certificate");
       SSL_CTX_free(ctx);
       return NULL;
     }
@@ -79,8 +77,8 @@ static SSL_CTX *create_ssl_ctx(bool is_server, const char *cert,
   return ctx;
 }
 
-static SSL *wrap_fd_with_ssl(int fd, SSL_CTX *ctx, bool is_server) {
-  SSL *ssl = SSL_new(ctx);
+static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server) {
+  SSL* ssl = SSL_new(ctx);
   if (!ssl) {
     log_message(LOG_LEVEL_ERROR, "Failed to create SSL object");
     return NULL;
@@ -93,8 +91,7 @@ static SSL *wrap_fd_with_ssl(int fd, SSL_CTX *ctx, bool is_server) {
     ret = SSL_connect(ssl);
 
   if (ret <= 0) {
-    log_message(LOG_LEVEL_ERROR, "SSL %s failed",
-                is_server ? "accept" : "connect");
+    log_message(LOG_LEVEL_ERROR, "SSL %s failed", is_server ? "accept" : "connect");
     log_ssl_errors();
     SSL_free(ssl);
     return NULL;
@@ -102,23 +99,25 @@ static SSL *wrap_fd_with_ssl(int fd, SSL_CTX *ctx, bool is_server) {
   return ssl;
 }
 
-bool server_create_tls(Server *server, const char *cert_path,
-                        const char *key_path, const char *ca_path) {
-  SSL_CTX *ctx = create_ssl_ctx(true, cert_path, key_path, ca_path);
-  if (!ctx) return false;
+bool server_create_tls(Server* server, const char* cert_path, const char* key_path,
+                       const char* ca_path) {
+  SSL_CTX* ctx = create_ssl_ctx(true, cert_path, key_path, ca_path);
+  if (!ctx)
+    return false;
   server->ssl_ctx = ctx;
   return true;
 }
 
 struct tls_child_ctx {
   void (*handler)(int);
-  SSL_CTX *ssl_ctx;
+  SSL_CTX* ssl_ctx;
 };
 
-static void tls_child_fn(int fd, void *arg) {
-  struct tls_child_ctx *ctx = (struct tls_child_ctx *)arg;
-  SSL *ssl = wrap_fd_with_ssl(fd, ctx->ssl_ctx, true);
-  if (!ssl) return;
+static void tls_child_fn(int fd, void* arg) {
+  struct tls_child_ctx* ctx = (struct tls_child_ctx*)arg;
+  SSL* ssl = wrap_fd_with_ssl(fd, ctx->ssl_ctx, true);
+  if (!ssl)
+    return;
   io_set_ssl(ssl);
   ctx->handler(fd);
   SSL_shutdown(ssl);
@@ -126,31 +125,31 @@ static void tls_child_fn(int fd, void *arg) {
   io_set_ssl(NULL);
 }
 
-bool server_listen_tls(Server *server, void (*handler)(int file_descriptor)) {
-  struct tls_child_ctx ctx = {handler, (SSL_CTX *)server->ssl_ctx};
+bool server_listen_tls(Server* server, void (*handler)(int file_descriptor)) {
+  struct tls_child_ctx ctx = {handler, (SSL_CTX*)server->ssl_ctx};
   server_accept_loop(server, tls_child_fn, &ctx, "Received TLS Connection");
   return true;
 }
 
-bool client_connect_tls(Client *client, char *host, int port,
-                         const char *cert_path, const char *key_path,
-                         const char *ca_path) {
+bool client_connect_tls(Client* client, char* host, int port, const char* cert_path,
+                        const char* key_path, const char* ca_path) {
   client->address.sin_port = htons(port);
   if (inet_pton(AF_INET, host, &client->address.sin_addr) <= 0) {
     perror("Could not convert host address!");
     return false;
   }
-  if (connect(client->file_descriptor, (struct sockaddr *)&client->address,
-               client->address_length) < 0) {
+  if (connect(client->file_descriptor, (struct sockaddr*)&client->address, client->address_length) <
+      0) {
     perror("Could not connect to Server!");
     return false;
   }
 
-  SSL_CTX *ctx = create_ssl_ctx(false, cert_path, key_path, ca_path);
-  if (!ctx) return false;
+  SSL_CTX* ctx = create_ssl_ctx(false, cert_path, key_path, ca_path);
+  if (!ctx)
+    return false;
   client->ssl_ctx = ctx;
 
-  SSL *ssl = wrap_fd_with_ssl(client->file_descriptor, ctx, false);
+  SSL* ssl = wrap_fd_with_ssl(client->file_descriptor, ctx, false);
   if (!ssl) {
     SSL_CTX_free(ctx);
     client->ssl_ctx = NULL;

src/shared/transport_tls.h

@@ -6,11 +6,10 @@
 
 bool tls_global_init(void);
 
-bool server_create_tls(Server *server, const char *cert_path,
-                        const char *key_path, const char *ca_path);
-bool server_listen_tls(Server *server, void (*handler)(int file_descriptor));
-bool client_connect_tls(Client *client, char *host, int port,
-                         const char *cert_path, const char *key_path,
-                         const char *ca_path);
+bool server_create_tls(Server* server, const char* cert_path, const char* key_path,
+                       const char* ca_path);
+bool server_listen_tls(Server* server, void (*handler)(int file_descriptor));
+bool client_connect_tls(Client* client, char* host, int port, const char* cert_path,
+                        const char* key_path, const char* ca_path);
 
 #endif

src/shared/utils.c

@@ -8,21 +8,25 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-bool mkdir_r(char *path) {
-  char *path_duplicate = malloc(strlen(path) + 1);
-  if (!path_duplicate) return false;
+bool mkdir_r(const char* path) {
+  char* path_duplicate = malloc(strlen(path) + 1);
+  if (!path_duplicate)
+    return false;
   strcpy(path_duplicate, path);
-  char *path_current = (char *)malloc((strlen(path) + 2) * sizeof(char));
-  if (!path_current) { free(path_duplicate); return false; }
-  char *path_current_position = path_current;
+  char* path_current = (char*)malloc((strlen(path) + 2) * sizeof(char));
+  if (!path_current) {
+    free(path_duplicate);
+    return false;
+  }
+  char* path_current_position = path_current;
   if (path[0] == '/') {
     strcpy(path_current, "/");
     path_current_position += 1;
   } else {
     path_current[0] = '\0';
   }
-  const char *delimiter = "/";
-  char *part = strtok(path_duplicate, delimiter);
+  const char* delimiter = "/";
+  const char* part = strtok(path_duplicate, delimiter);
   bool ok = true;
   while (part != NULL) {
     strcpy(path_current_position, part);
@@ -44,15 +48,15 @@ bool mkdir_r(char *path) {
   return ok;
 }
 
-char *str_dup(const char *string) {
+char* str_dup(const char* string) {
   if (string == NULL)
     return NULL;
-  char *new_string = (char *)malloc(strlen(string) + 1);
+  char* new_string = (char*)malloc(strlen(string) + 1);
   strcpy(new_string, string);
   return new_string;
 }
 
-bool glob_match(const char *pattern, const char *str) {
+bool glob_match(const char* pattern, const char* str) {
   while (*pattern) {
     if (*pattern == '*') {
       pattern++;
@@ -77,17 +81,16 @@ bool glob_match(const char *pattern, const char *str) {
   return *str == '\0';
 }
 
-static void delete_extras_walk(const char *abs_path, const char *rel_path,
-                               ArrayList *manifest) {
-  DIR *dir = opendir(abs_path);
+static void delete_extras_walk(const char* abs_path, const char* rel_path, ArrayList* manifest) {
+  DIR* dir = opendir(abs_path);
   if (!dir)
     return;
-  struct dirent *entry;
+  struct dirent* entry;
   while ((entry = readdir(dir)) != NULL) {
     if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
       continue;
-    char *child_abs = path_cat((char *)abs_path, entry->d_name);
-    char *child_rel = path_cat((char *)rel_path, entry->d_name);
+    char* child_abs = path_cat((char*)abs_path, entry->d_name);
+    char* child_rel = path_cat((char*)rel_path, entry->d_name);
     struct stat st;
     if (stat(child_abs, &st) != 0) {
       free(child_abs);
@@ -100,7 +103,7 @@ static void delete_extras_walk(const char *abs_path, const char *rel_path,
       // Check if relative path is in manifest
       bool found = false;
       for (int i = 0; i < manifest->size; i++) {
-        if (strcmp((char *)manifest->items[i], child_rel) == 0) {
+        if (strcmp((char*)manifest->items[i], child_rel) == 0) {
           found = true;
           break;
         }
@@ -117,26 +120,27 @@ static void delete_extras_walk(const char *abs_path, const char *rel_path,
   rmdir(abs_path);
 }
 
-void delete_extras(const char *dest_root, ArrayList *manifest) {
+void delete_extras(const char* dest_root, ArrayList* manifest) {
   delete_extras_walk(dest_root, "", manifest);
 }
 
-char *path_cat(char *path1, char *path2) {
+char* path_cat(const char* path1, char* path2) {
   if (path1 == NULL || *path1 == '\0')
     return str_dup(path2);
   if (path2 == NULL || *path2 == '\0')
     return str_dup(path1);
   int path1_len = strlen(path1);
   int path2_len = strlen(path2);
-  char *path2_pointer = path2;
+  char* path2_pointer = path2;
   if (path1[path1_len - 1] == '/')
     path1_len -= 1;
   if (path2[0] == '/') {
     path2_pointer += 1;
     path2_len -= 1;
   }
-  char *new_path = malloc(path1_len + path2_len + 2);
-  if (new_path == NULL) return NULL;
+  char* new_path = malloc(path1_len + path2_len + 2);
+  if (new_path == NULL)
+    return NULL;
   memcpy(new_path, path1, path1_len);
   new_path[path1_len] = '/';
   memcpy(new_path + path1_len + 1, path2_pointer, path2_len);

src/shared/utils.h

@@ -4,10 +4,10 @@
 #include "array_list.h"
 #include <stdbool.h>
 
-bool mkdir_r(char *path);
-char *str_dup(const char *string);
-char *path_cat(char *path1, char *path2);
-bool glob_match(const char *pattern, const char *str);
-void delete_extras(const char *dest_root, ArrayList *manifest);
+bool mkdir_r(const char* path);
+char* str_dup(const char* string);
+char* path_cat(const char* path1, char* path2);
+bool glob_match(const char* pattern, const char* str);
+void delete_extras(const char* dest_root, ArrayList* manifest);
 
 #endif